Further tweaks to inliner

Author: odersky

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

@@ -104,22 +104,134 @@ object Inliner {
    *                     to have the inlined method as owner.
    */
   def registerInlineInfo(
-      sym: SymDenotation, originalBody: untpd.Tree, treeExpr: Context => Tree)(implicit ctx: Context): Unit = {
-    sym.unforcedAnnotation(defn.BodyAnnot) match {
+      inlined: Symbol, originalBody: untpd.Tree, treeExpr: Context => Tree)(implicit ctx: Context): Unit = {
+    inlined.unforcedAnnotation(defn.BodyAnnot) match {
       case Some(ann: ConcreteBodyAnnotation) =>
       case Some(ann: LazyBodyAnnotation) if ann.isEvaluated =>
       case _ =>
         if (!ctx.isAfterTyper) {
           val inlineCtx = ctx
-          sym.updateAnnotation(LazyBodyAnnotation { _ =>
+          inlined.updateAnnotation(LazyBodyAnnotation { _ =>
             implicit val ctx = inlineCtx
-            val body = treeExpr(ctx)
-            if (ctx.reporter.hasErrors) body else ctx.compilationUnit.inlineAccessors.makeInlineable(body)
+            val rawBody = treeExpr(ctx)
+            val typedBody =
+              if (ctx.reporter.hasErrors) rawBody
+              else ctx.compilationUnit.inlineAccessors.makeInlineable(rawBody)
+            val inlineableBody =
+              if (inlined.isInlinedMethod) typedBody
+              else addReferences(inlined, originalBody, typedBody)
+            inlining.println(i"Body to inline for $inlined: $inlineableBody")
+            inlineableBody
           })
         }
     }
   }
 
+  /** Tweak untyped tree `original` so that all external references are typed
+   *  and it reflects the changes in the corresponding typed tree `typed` that
+   *  make `typed` inlineable. Concretely:
+   *
+   *   - all external references via identifiers or this-references are converted
+   *     to typed splices,
+   *   - if X gets an inline accessor in `typed`, references to X in `original`
+   *     are converted to the inline accessor name.
+   */
+  def addReferences(inlineMethod: Symbol,
+      original: untpd.Tree, typed: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+
+    def isExternal(sym: Symbol) = sym.exists && !isLocal(sym, inlineMethod)
+
+    // Maps from positions to external reference types and inline selector names.
+    object referenced extends TreeTraverser {
+      val typeAtPos = mutable.Map[Position, Type]()
+      val nameAtPos = mutable.Map[Position, Name]()
+      val implicitSyms = mutable.Set[Symbol]()
+      val implicitRefs = new mutable.ListBuffer[Tree]
+      def registerIfContextualImplicit(tree: Tree) = tree match {
+        case tree: RefTree
+        if tree.removeAttachment(ContextualImplicit).isDefined &&
+           isExternal(tree.symbol) &&
+           !implicitSyms.contains(tree.symbol) =>
+          if (tree.existsSubTree(t => isLocal(tree.symbol, inlineMethod)))
+            ctx.warning("implicit reference $tree is dropped at inline site because it refers to local symbol(s)", tree.pos)
+          else {
+            implicitSyms += tree.symbol
+            implicitRefs += tree
+          }
+        case _ =>
+      }
+      def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+        tree match {
+          case _: Ident | _: This =>
+            //println(i"leaf: $tree at ${tree.pos}")
+            if (isExternal(tree.symbol)) {
+              inlining.println(i"type at pos ${tree.pos.toSynthetic} = ${tree.tpe}")
+              typeAtPos(tree.pos.toSynthetic) = tree.tpe
+            }
+          case _: Select if tree.symbol.name.is(InlineAccessorName) =>
+            inlining.println(i"accessor: $tree at ${tree.pos}")
+            nameAtPos(tree.pos.toSynthetic) = tree.symbol.name
+          case _ =>
+        }
+        registerIfContextualImplicit(tree)
+        traverseChildren(tree)
+      }
+    }
+    referenced.traverse(typed)
+
+    // The untyped tree transform that applies the tweaks
+    object addRefs extends untpd.UntypedTreeMap {
+      override def transform(tree: untpd.Tree)(implicit ctx: Context): untpd.Tree = {
+        def adjustLeaf(tree: untpd.Tree): untpd.Tree = referenced.typeAtPos.get(tree.pos.toSynthetic) match {
+          case Some(tpe) => untpd.TypedSplice(tree.withType(tpe))
+          case none => tree
+        }
+        def adjustName(name: Name) = referenced.nameAtPos.get(tree.pos.toSynthetic) match {
+          case Some(n) => n
+          case none => name
+        }
+        def adjustQualifier(tree: untpd.Tree): untpd.Tree = tree match {
+          case tree @ Ident(name1) =>
+            referenced.typeAtPos.get(tree.pos.startPos) match {
+              case Some(tp: ThisType) =>
+                val qual = untpd.TypedSplice(This(tp.cls).withPos(tree.pos.startPos))
+                cpy.Select(tree)(qual, name1)
+              case none =>
+                tree
+            }
+          case tree => tree
+        }
+        val tree1 = super.transform(tree)
+        tree1 match {
+          case This(_) =>
+            adjustLeaf(tree1)
+          case Ident(name) =>
+            adjustQualifier(adjustLeaf(cpy.Ident(tree1)(adjustName(name))))
+          case Select(pre, name) =>
+            cpy.Select(tree1)(pre, adjustName(name))
+          case tree: untpd.DerivedTypeTree =>
+            inlining.println(i"inlining derived $tree --> ${ctx.typer.typed(tree)}")
+            untpd.TypedSplice(ctx.typer.typed(tree))
+          case _ =>
+            tree1
+        }
+      }
+    }
+    val implicitBindings =
+      for (iref <- referenced.implicitRefs.toList) yield {
+        val localImplicit = iref.symbol.asTerm.copy(
+          owner = inlineMethod,
+          name = UniqueName.fresh(iref.symbol.name.asTermName),
+          flags = Implicit | Method | Stable,
+          info = iref.symbol.info.ensureMethodic,
+          coord = inlineMethod.pos).asTerm
+        polyDefDef(localImplicit, tps => vrefss =>
+            iref.appliedToTypes(tps).appliedToArgss(vrefss))
+      }
+    val untpdSplice = tpd.UntypedSplice(addRefs.transform(original)).withType(typed.tpe)
+    seq(implicitBindings, untpdSplice)
+  }
+
   /** `sym` has an inline method with a known body to inline (note: definitions coming
    *  from Scala2x class files might be `@inline`, but still lack that body.
    */
@@ -383,12 +495,32 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     val inlineTyper = new InlineTyper
     val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
+
     // The complete translation maps references to `this` and parameters to
     // corresponding arguments or proxies on the type and term level. It also changes
     // the owner from the inlined method to the current owner.
     val inliner = new TreeTypeMap(typeMap, treeMap, meth :: Nil, ctx.owner :: Nil)(inlineCtx)
 
-    val expansion = inliner(rhsToInline.withPos(call.pos))
+    val expansion = inliner.transform(rhsToInline.withPos(call.pos)) match {
+      case Block(implicits, tpd.UntypedSplice(expansion)) =>
+        val prevOwners = implicits.map(_.symbol.owner).distinct
+        val localizer = new TreeTypeMap(oldOwners = prevOwners, newOwners = prevOwners.map(_ => ctx.owner))
+        val (_, implicits1) = localizer.transformDefs(implicits)
+        for (idef <- implicits1) {
+          bindingsBuf += idef.withType(idef.symbol.typeRef).asInstanceOf[ValOrDefDef]
+            // Note: Substituting new symbols does not automatically lead to good prefixes
+            // if the previous symbol was owned by a class. That's why we need to set the type
+            // of `idef` explicitly. It would be nice if substituters were smarter, but
+            // it seems non-trivial to come up with rules that work in
+          inlineCtx.enter(idef.symbol)
+        }
+        expansion
+      case tpd.UntypedSplice(expansion) =>
+        expansion
+      case expansion =>
+        expansion
+    }
+
     trace(i"inlining $call\n, BINDINGS =\n${bindingsBuf.toList}%\n%\nEXPANSION =\n$expansion", inlining, show = true) {
 
       // The final expansion runs a typing pass over the inlined tree. See InlineTyper for details.

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

@@ -821,13 +821,13 @@ class Namer { typer: Typer =>
       else completeInCreationContext(denot)
     }
 
-    private def addInlineInfo(denot: SymDenotation) = original match {
-      case original: untpd.DefDef if denot.isInlineableMethod =>
+    private def addInlineInfo(sym: Symbol) = original match {
+      case original: untpd.DefDef if sym.isInlineableMethod =>
         Inliner.registerInlineInfo(
-            denot,
+            sym,
             original.rhs,
             implicit ctx => typedAheadExpr(original).asInstanceOf[tpd.DefDef].rhs
-          )(localContext(denot.symbol))
+          )(localContext(sym))
       case _ =>
     }
 
@@ -840,7 +840,7 @@ class Namer { typer: Typer =>
         case original: MemberDef => addAnnotations(sym, original)
         case _ =>
       }
-      addInlineInfo(denot)
+      addInlineInfo(sym)
       denot.info = typeSig(sym)
       Checking.checkWellFormed(sym)
       denot.info = avoidPrivateLeaks(sym, sym.pos)

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

@@ -1891,7 +1891,7 @@ class Typer extends Namer
                     // from separately compiled files - the original BodyAnnotation is not kept.
                 }
                 else {
-                  assert(mdef.symbol.isTransparentMethod)
+                  assert(mdef1.symbol.isTransparentMethod, mdef.symbol)
                   Inliner.bodyToInline(mdef1.symbol) // just make sure accessors are computed,
                   buf += mdef1                       // but keep original definition, since inline-expanded code
                                                      // is pickled in this case.