Add bindings inside the expansion

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -603,6 +603,7 @@ object Trees {
    */
   case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends Tree[T] {
+    assert(bindings.isEmpty)
     type ThisTree[-T >: Untyped] = Inlined[T]
   }
 

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -520,9 +520,18 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
       if (inlinedMethod == defn.Compiletime_error) issueError()
 
-      // Take care that only argument bindings go into `bindings`, since positions are
-      // different for bindings from arguments and bindings from body.
-      tpd.Inlined(call, finalBindings, finalExpansion)
+      // Widen TermRefs to bindings
+      val finalExpansion2 = finalExpansion.tpe match {
+        case tpe: TermRef if finalBindings.exists(x => x.symbol == tpe.symbol) =>
+          // If the return type of an inline function is a singleton type of a parameter (like in `DottyPredef.the`)
+          // the expansion will be `{ val x = y; (x: x.type) }`. We ascribe the type to itself widening the
+          // local TermRef of the binding `{ val x = y; (x: y.type) }`.
+          tpd.Typed(finalExpansion, TypeTree(ctx.typer.avoidingType(finalExpansion, finalBindings))).withSpan(finalExpansion.span)
+        case _ =>
+          finalExpansion
+      }
+
+      tpd.Inlined(call, Nil, tpd.seq(finalBindings, finalExpansion2))
     }
   }
 

tests/pos/inlined-the.scala

@@ -0,0 +1,41 @@
+
+object Instances {
+
+  class D[T]
+
+  class C {
+    def f() = {
+      locally {
+        implied d[T] for D[T]
+        the[D[Int]]
+        implicit val s: 3 = ???
+        val a: 3 = the[3]
+        val b: s.type = the[s.type]
+        ()
+      }
+
+      locally {
+        implied d[T] for D[T]
+        the2[D[Int]]
+        implicit val s: 3 = ???
+        val a: 3 = the2[3]
+        val b: s.type = the2[s.type]
+        ()
+      }
+
+      locally {
+        implicit val s: List[3] = ???
+        val a: List[3] = the2[List[3]]
+
+        implicit val sl: List[s.type] = ???
+        val b: List[s.type] = the2[List[s.type]]
+        ()
+      }
+    }
+  }
+
+  inline def the2[T](implicit x: T): x.type = x
+
+  inline def theList[T](implicit x: T): List[x.type] = List[x.type](x)
+
+}