Bring back typed inliner

Author: odersky

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -309,7 +309,7 @@ object Contexts {
 
     /** Is this a context for typechecking an inlined body? */
     def isInlineContext: Boolean =
-      typer.isInstanceOf[Inliner#InlineTyper]
+      typer.isInstanceOf[Inliner#InlineTyping]
 
     /** The next outer context whose tree is a template or package definition
      *  Note: Currently unused

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -652,7 +652,9 @@ class TreePickler(pickler: TastyPickler) {
       // a different toplevel class, it is impossible to pickle a reference to it.
       // Such annotations will be reconstituted when unpickling the child class.
       // See tests/pickling/i3149.scala
-    case _ => false
+    case _ =>
+      if (Inliner.typedInline) ann.symbol == defn.BodyAnnot // inline bodies are reconstituted automatically when unpickling
+      else false
   }
 
   def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context) =

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -24,6 +24,7 @@ import core.quoted.PickledQuotes
 import scala.quoted
 import scala.quoted.Types.TreeType
 import scala.quoted.Exprs.TastyTreeExpr
+import typer.Inliner.typedInline
 
 import scala.annotation.internal.sharable
 
@@ -556,6 +557,12 @@ class TreeUnpickler(reader: TastyReader,
         sym.completer.withDecls(newScope)
         forkAt(templateStart).indexTemplateParams()(localContext(sym))
       }
+      else if (typedInline && sym.isInlineMethod)
+        sym.addAnnotation(LazyBodyAnnotation { ctx0 =>
+          implicit val ctx: Context = localContext(sym)(ctx0).addMode(Mode.ReadPositions)
+            // avoids space leaks by not capturing the current context
+          forkAt(rhsStart).readTerm()
+        })
       goto(start)
       sym
     }
@@ -637,8 +644,10 @@ class TreeUnpickler(reader: TastyReader,
         val lazyAnnotTree = readLaterWithOwner(end, rdr => ctx => rdr.readTerm()(ctx))
 
         owner =>
-          if (tp.isRef(defn.BodyAnnot))
+          if (tp.isRef(defn.BodyAnnot)) {
+            assert(!typedInline)
             LazyBodyAnnotation(implicit ctx => lazyAnnotTree(owner).complete)
+          }
           else
             Annotation.deferredSymAndTree(
               implicit ctx => tp.typeSymbol,
@@ -741,6 +750,11 @@ class TreeUnpickler(reader: TastyReader,
       def readRhs(implicit ctx: Context) =
         if (nothingButMods(end))
           EmptyTree
+        else if (sym.isInlineMethod && typedInline)
+          // The body of an inline method is stored in an annotation, so no need to unpickle it again
+          new Trees.Lazy[Tree] {
+            def complete(implicit ctx: Context) = typer.Inliner.bodyToInline(sym)
+          }
         else
           readLater(end, rdr => ctx => rdr.readTerm()(ctx.retractMode(Mode.InSuperCall)))
 

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

@@ -34,6 +34,8 @@ import ast.TreeInfo
 object Inliner {
   import tpd._
 
+  val typedInline = true
+
   /** A key to be used in a context property that provides a map from enclosing implicit
    *  value bindings to their right hand sides.
    */
@@ -382,7 +384,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     // Compute bindings for all this-proxies, appending them to bindingsBuf
     computeThisBindings()
 
-    val inlineTyper = new InlineTyper
+    val inlineTyper =
+      if (typedInline) new InlineReTyper else new TransparentTyper
+
     val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
 
     // A tree type map to prepare the inlined body for typechecked.
@@ -857,7 +861,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)
    */
-  class InlineTyper extends Typer {
+  trait InlineTyping extends Typer {
     import reducer._
 
     override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = {
@@ -873,12 +877,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       super.ensureAccessible(tpe, superAccess, pos)
     }
 
-    override def typedTypedSplice(tree: untpd.TypedSplice)(implicit ctx: Context): Tree =
-      reduceProjection(tryInline(tree.splice) `orElse` super.typedTypedSplice(tree))
-
-    override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context) =
-      constToLiteral(reduceProjection(super.typedSelect(tree, pt)))
-
     override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) =
       typed(tree.cond, defn.BooleanType) match {
         case cond1 @ ConstantValue(b: Boolean) =>
@@ -895,6 +893,19 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           super.typedIf(if1, pt)
       }
 
+    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
+      constToLiteral(betaReduce(super.typedApply(tree, pt)))
+  }
+
+  private class TransparentTyper extends Typer with InlineTyping {
+    import reducer._
+
+    override def typedTypedSplice(tree: untpd.TypedSplice)(implicit ctx: Context): Tree =
+      reduceProjection(tryInline(tree.splice) `orElse` super.typedTypedSplice(tree))
+
+    override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context) =
+      constToLiteral(reduceProjection(super.typedSelect(tree, pt)))
+
     override def typedMatchFinish(tree: untpd.Match, sel: Tree, selType: Type, pt: Type)(implicit ctx: Context) = tree match {
       case _: untpd.InlineMatch if !ctx.owner.isInlineMethod => // don't reduce match of nested inline method yet
         reduceInlineMatch(sel, sel.tpe, tree.cases, this) match {
@@ -916,10 +927,24 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
         super.typedMatchFinish(tree, sel, selType, pt)
     }
 
-    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
-      constToLiteral(betaReduce(super.typedApply(tree, pt)))
+    override def newLikeThis: Typer = new TransparentTyper
+  }
+
+  private class InlineReTyper extends ReTyper with InlineTyping {
+    import reducer._
+
+    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) =
+      tryInline(tree.asInstanceOf[tpd.Tree]) `orElse` super.typedIdent(tree, pt)
+
+    override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
+      assert(tree.hasType, tree)
+      val qual1 = typed(tree.qualifier, selectionProto(tree.name, pt, this))
+      val res = untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
+      ensureAccessible(res.tpe, tree.qualifier.isInstanceOf[untpd.Super], tree.pos)
+      res
+    }
 
-    override def newLikeThis: Typer = new InlineTyper
+    override def newLikeThis: Typer = new InlineReTyper
   }
 
   /** Drop any side-effect-free bindings that are unused in expansion or other reachable bindings.

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

@@ -243,9 +243,10 @@ object PrepareInlineable {
             val typedBody =
               if (ctx.reporter.hasErrors) rawBody
               else ctx.compilationUnit.inlineAccessors.makeInlineable(rawBody)
-            if (inlined.isInlineMethod)
-              checkInlineMethod(inlined, typedBody)
-            val inlineableBody = addReferences(inlined, originalBody, typedBody)
+            checkInlineMethod(inlined, typedBody)
+            val inlineableBody =
+              if (Inliner.typedInline) typedBody
+              else addReferences(inlined, originalBody, typedBody)
             inlining.println(i"Body to inline for $inlined: $inlineableBody")
             inlineableBody
           })

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

@@ -81,7 +81,7 @@ object ProtoTypes {
      *  achieved by replacing expected type parameters with wildcards.
      */
     def constrainResult(meth: Symbol, mt: Type, pt: Type)(implicit ctx: Context): Boolean =
-      if (Inliner.isInlineable(meth)) {
+      if (Inliner.isInlineable(meth) && !Inliner.typedInline) {
         constrainResult(mt, wildApprox(pt))
         true
       }

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

@@ -117,6 +117,8 @@ class ReTyper extends Typer with ReChecking {
         throw ex
     }
 
+  override def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree = mdef
+
   override def checkVariance(tree: Tree)(implicit ctx: Context) = ()
   override def inferView(from: Tree, to: Type)(implicit ctx: Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure

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

@@ -711,7 +711,7 @@ class Typer extends Namer
   }
 
   def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree = track("typedIf") {
-    if (tree.isInstanceOf[untpd.InlineIf]) checkInInlineContext("inline if", tree.pos)
+    if (tree.isInstanceOf[untpd.InlineIf] && !Inliner.typedInline) checkInInlineContext("inline if", tree.pos)
     val cond1 = typed(tree.cond, defn.BooleanType)
     val thenp2 :: elsep2 :: Nil = harmonic(harmonize) {
       val thenp1 = typed(tree.thenp, pt.notApplied)
@@ -981,7 +981,7 @@ class Typer extends Namer
         val sel1 = id.withType(defn.ImplicitScrutineeTypeRef)
         typedMatchFinish(tree, sel1, sel1.tpe, pt)
       case _ =>
-        if (tree.isInstanceOf[untpd.InlineMatch]) checkInInlineContext("inline match", tree.pos)
+        if (tree.isInstanceOf[untpd.InlineMatch] && !Inliner.typedInline) checkInInlineContext("inline match", tree.pos)
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.pos).widen
         typedMatchFinish(tree, sel1, selType, pt)
@@ -1992,10 +1992,17 @@ class Typer extends Namer
           case none =>
             typed(mdef) match {
               case mdef1: DefDef if Inliner.hasBodyToInline(mdef1.symbol) =>
-                assert(mdef1.symbol.isInlineMethod, 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.
+                if (Inliner.typedInline) {
+                  buf += inlineExpansion(mdef1)
+                    // replace body with expansion, because it will be used as inlined body
+                    // from separately compiled files - the original BodyAnnotation is not kept.
+                }
+                else {
+                  assert(mdef1.symbol.isInlineMethod, 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.
+                }
               case mdef1 =>
                 import untpd.modsDeco
                 mdef match {
@@ -2027,6 +2034,13 @@ class Typer extends Namer
     checkEnumCompanions(traverse(stats)(localCtx), enumContexts)
   }
 
+  /** Given an inline method `mdef`, the method rewritten so that its body
+   *  uses accessors to access non-public members.
+   *  Overwritten in Retyper to return `mdef` unchanged.
+   */
+  protected def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree =
+    tpd.cpy.DefDef(mdef)(rhs = Inliner.bodyToInline(mdef.symbol))
+
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, pt)(ctx retractMode Mode.PatternOrTypeBits)
   def typedType(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = // todo: retract mode between Type and Pattern?
@@ -2438,8 +2452,9 @@ class Typer extends Namer
       else if (Inliner.isInlineable(tree) &&
                !ctx.settings.YnoInline.value &&
                !ctx.isAfterTyper &&
-               !ctx.reporter.hasErrors) {
-        tree.tpe <:< wildApprox(pt)
+               !ctx.reporter.hasErrors &&
+               (!Inliner.typedInline || tree.tpe <:< pt)) {
+        if (!Inliner.typedInline) tree.tpe <:< wildApprox(pt)
         readaptSimplified(Inliner.inlineCall(tree, pt))
       }
       else if (tree.tpe <:< pt) {