Dual function inliner

Should inline both inline methods with fully-typed expansions
and transparent methods with partially untyped extensions.

Author: odersky

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

@@ -15,7 +15,7 @@ import StdNames.nme
 import Contexts.Context
 import Names.{Name, TermName, EmptyTermName}
 import NameOps._
-import NameKinds.{ClassifiedNameKind, InlineAccessorName}
+import NameKinds.{ClassifiedNameKind, InlineAccessorName, UniqueName}
 import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
 import Annotations._
@@ -63,23 +63,13 @@ object Inliner {
       // This is quite tricky, as such types can appear anywhere, including as parts
       // of types of other things. For the moment we do nothing and complain
       // at the implicit expansion site if there's a reference to an inaccessible type.
-      override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
-        case tree: Assign =>
-          transform(tree.lhs) match {
-            case lhs1: RefTree =>
-              lhs1.name match {
-                case InlineAccessorName(name) =>
-                  cpy.Apply(tree)(useSetter(lhs1), transform(tree.rhs) :: Nil)
-                case _ =>
-                  super.transform(tree)
-              }
-            case _ =>
-              super.transform(tree)
-          }
-        case _ =>
-          super.transform(accessorIfNeeded(tree))
-      }
-
+      override def transform(tree: Tree)(implicit ctx: Context): Tree =
+        super.transform(accessorIfNeeded(tree)) match {
+          case tree1 @ Assign(lhs: RefTree, rhs) if lhs.symbol.name.is(InlineAccessorName) =>
+            cpy.Apply(tree1)(useSetter(lhs), rhs :: Nil)
+          case tree1 =>
+            tree1
+        }
     }
 
     /** Adds accessors for all non-public term members accessed
@@ -391,7 +381,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       case _ => tree
     }}
 
-    val inlineCtx = inlineContext(call)
+    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.
@@ -401,7 +392,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     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.
-      val expansion1 = InlineTyper.typed(expansion, pt)(inlineCtx)
+      val expansion1 = inlineTyper.typed(expansion, pt)(inlineCtx)
 
       /** All bindings in `bindingsBuf` except bindings of inlineable closures */
       val bindings = bindingsBuf.toList.map(_.withPos(call.pos))
@@ -421,8 +412,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    */
   private object InlineableArg {
     lazy val paramProxies = paramProxy.values.toSet
-    def unapply(tree: Ident)(implicit ctx: Context): Option[Tree] =
-      if (paramProxies.contains(tree.tpe))
+    def unapply(tree: Trees.Ident[_])(implicit ctx: Context): Option[Tree] =
+      if (paramProxies.contains(tree.typeOpt))
         bindingsBuf.find(_.name == tree.name) match {
           case Some(vdef: ValDef) if vdef.symbol.is(Inline) =>
             Some(vdef.rhs.changeOwner(vdef.symbol, ctx.owner))
@@ -440,7 +431,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    *  4. Make sure inlined code is type-correct.
    *  5. Make sure that the tree's typing is idempotent (so that future -Ycheck passes succeed)
    */
-  private object InlineTyper extends ReTyper {
+  private class InlineTyper extends ReTyper {
 
     override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = {
       tpe match {
@@ -507,6 +498,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
       betaReduce(super.typedApply(tree, pt))
     }
+
+    override def newLikeThis: Typer = new InlineTyper
   }
 
   /** Drop any side-effect-free bindings that are unused in expansion or other reachable bindings.