Go back to inlining during typing

Reverts the following commits:

Join containsQuotesOrSplices and containsInlineCalls (reverted from commit 8cf1385)
Make InlineCalls an object (reverted from commit ad26554)
Remove Inlined and InlineProxy from TASTy (reverted from commit 976e095)
Move inlining inside Reify quotes

Split some neg tests as now only the first error is emitted. (reverted from commit 21e65f1)
Erase rhs of erased non inlined val/def in PostTyper (reverted from commit c12e875)
Add isInlineCall to TreeInfo (reverted from commit 954c25b)
Update doc (reverted from commit 0832e02)
Only run InlineCalls if the tree contains an inline call (reverted from commit f28e2e1)
Check if unpickled tree has inline nodes (reverted from commit 927ae4e)
Add a bit of documentation (reverted from commit da0c249)
Fix constant folding during inlining (reverted from commit 32c8798)
Move inline β-reduction after Pickler (reverted from commit c68dc1f)
Normalize call at Inlined node creation (reverted from commit 746fdd7)
Move inline β-reduction after post typer (reverted from commit 432eb0a)
Move inline β-reduction out of typer (reverted from commit 6acaf31)

Author: odersky

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -3,14 +3,12 @@ package dotc
 
 import util.SourceFile
 import ast.{tpd, untpd}
-import dotty.tools.dotc.ast.Trees
 import tpd.{Tree, TreeTraverser}
 import typer.PrepareInlineable.InlineAccessors
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.typer.Inliner
 
 class CompilationUnit(val source: SourceFile) {
 
@@ -25,8 +23,8 @@ class CompilationUnit(val source: SourceFile) {
   /** Pickled TASTY binaries, indexed by class. */
   var pickled: Map[ClassSymbol, Array[Byte]] = Map()
 
-  /** Will be set to `true` if contains `Quote`, `Splice` or calls to inline methods.
-   * The information is used in phase `Staging` in order to avoid traversing a quote-less tree.
+  /** Will be set to `true` if contains `Quote`.
+   *  The information is used in phase `Staging` in order to avoid traversing trees that need no transformations.
    */
   var needsStaging: Boolean = false
 
@@ -57,8 +55,7 @@ object CompilationUnit {
   private class Force extends TreeTraverser {
     var needsStaging = false
     def traverse(tree: Tree)(implicit ctx: Context): Unit = {
-      // Note that top-level splices are still inside the inline methods
-      if (tree.symbol.isQuote || tpd.isInlineCall(tree))
+      if (tree.symbol.isQuote)
         needsStaging = true
       traverseChildren(tree)
     }

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -44,7 +44,7 @@ class Compiler {
   /** Phases dealing with TASTY tree pickling and unpickling */
   protected def picklerPhases: List[List[Phase]] =
     List(new Pickler) ::            // Generate TASTY info
-    List(new Staging) ::            // Inline calls, expand macros and turn quoted trees into explicit run-time data structures
+    List(new Staging) ::            // Turn quoted trees into explicit run-time data structures
     Nil
 
   /** Phases dealing with the transformation from pickled trees to backend trees */

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

@@ -5,7 +5,7 @@ package ast
 import core._
 import Flags._, Trees._, Types._, Contexts._
 import Names._, StdNames._, NameOps._, Symbols._
-import typer.{ConstFold, Inliner}
+import typer.ConstFold
 import reporting.trace
 
 import scala.annotation.tailrec
@@ -770,14 +770,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       false
   }
 
-  /** Is this call a call to a method that is marked as Inline */
-  def isInlineCall(arg: Tree)(implicit ctx: Context): Boolean = arg match {
-    case _: RefTree | _: GenericApply[_] =>
-      !arg.tpe.widenDealias.isInstanceOf[MethodicType] && Inliner.isInlineable(arg)
-    case _ =>
-      false
-  }
-
   /** Structural tree comparison (since == on trees is reference equality).
    *  For the moment, only Ident, Select, Literal, Apply and TypeApply are supported
    */

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

@@ -585,8 +585,9 @@ object Trees {
 
   /** A tree representing inlined code.
    *
-   *  @param  call      Info about the original call that was inlined.
-   *                    Only a reference to the toplevel class from which the call was inlined.
+   *  @param  call      Info about the original call that was inlined
+   *                    Until PostTyper, this is the full call, afterwards only
+   *                    a reference to the toplevel class from which the call was inlined.
    *  @param  bindings  Bindings for proxies to be used in the inlined code
    *  @param  expansion The inlined tree, minus bindings.
    *

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

@@ -86,6 +86,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   TYPED          Length expr_Term ascriptionType_Tern
                   ASSIGN         Length lhs_Term rhs_Term
                   BLOCK          Length expr_Term Stat*
+                  INLINED        Length expr_Term call_Term? ValOrDefDef*
                   LAMBDA         Length meth_Term target_Type?
                   IF             Length cond_Term then_Term else_Term
                   MATCH          Length sel_Term CaseDef*
@@ -184,6 +185,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   OVERRIDE
                   INLINE
                   MACRO                               // inline method containing toplevel splices
+                  INLINEPROXY                         // symbol of binding representing an inline parameter
                   STATIC                              // mapped to static Java member
                   OBJECT                              // an object or its class
                   TRAIT                               // a trait
@@ -233,7 +235,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 13
+  val MajorVersion: Int = 11
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
@@ -286,25 +288,26 @@ object TastyFormat {
   final val IMPLICIT = 13
   final val LAZY = 14
   final val OVERRIDE = 15
-  final val INLINE = 16
-  final val STATIC = 17
-  final val OBJECT = 18
-  final val TRAIT = 19
-  final val ENUM = 20
-  final val LOCAL = 21
-  final val SYNTHETIC = 22
-  final val ARTIFACT = 23
-  final val MUTABLE = 24
-  final val FIELDaccessor = 25
-  final val CASEaccessor = 26
-  final val COVARIANT = 27
-  final val CONTRAVARIANT = 28
-  final val SCALA2X = 29
-  final val DEFAULTparameterized = 30
-  final val STABLE = 31
-  final val MACRO = 32
-  final val ERASED = 33
-  final val PARAMsetter = 34
+  final val INLINEPROXY = 16
+  final val INLINE = 17
+  final val STATIC = 18
+  final val OBJECT = 19
+  final val TRAIT = 20
+  final val ENUM = 21
+  final val LOCAL = 22
+  final val SYNTHETIC = 23
+  final val ARTIFACT = 24
+  final val MUTABLE = 25
+  final val FIELDaccessor = 26
+  final val CASEaccessor = 27
+  final val COVARIANT = 28
+  final val CONTRAVARIANT = 29
+  final val SCALA2X = 30
+  final val DEFAULTparameterized = 31
+  final val STABLE = 32
+  final val MACRO = 33
+  final val ERASED = 34
+  final val PARAMsetter = 35
 
   // Cat. 2:    tag Nat
 
@@ -378,35 +381,36 @@ object TastyFormat {
   final val RETURN = 144
   final val WHILE = 145
   final val TRY = 146
-  final val SELECTouter = 147
-  final val REPEATED = 148
-  final val BIND = 149
-  final val ALTERNATIVE = 150
-  final val UNAPPLY = 151
-  final val ANNOTATEDtype = 152
-  final val ANNOTATEDtpt = 153
-  final val CASEDEF = 154
-  final val TEMPLATE = 155
-  final val SUPER = 156
-  final val SUPERtype = 157
-  final val REFINEDtype = 158
-  final val REFINEDtpt = 159
-  final val APPLIEDtype = 160
-  final val APPLIEDtpt = 161
-  final val TYPEBOUNDS = 162
-  final val TYPEBOUNDStpt = 163
-  final val ANDtype = 164
-  final val ANDtpt = 165
-  final val ORtype = 166
-  final val ORtpt = 167
-  final val POLYtype = 168
-  final val TYPELAMBDAtype = 169
-  final val LAMBDAtpt = 170
-  final val PARAMtype = 171
-  final val ANNOTATION = 172
-  final val TERMREFin = 173
-  final val TYPEREFin = 174
-  final val OBJECTDEF = 175
+  final val INLINED = 147
+  final val SELECTouter = 148
+  final val REPEATED = 149
+  final val BIND = 150
+  final val ALTERNATIVE = 151
+  final val UNAPPLY = 152
+  final val ANNOTATEDtype = 153
+  final val ANNOTATEDtpt = 154
+  final val CASEDEF = 155
+  final val TEMPLATE = 156
+  final val SUPER = 157
+  final val SUPERtype = 158
+  final val REFINEDtype = 159
+  final val REFINEDtpt = 160
+  final val APPLIEDtype = 161
+  final val APPLIEDtpt = 162
+  final val TYPEBOUNDS = 163
+  final val TYPEBOUNDStpt = 164
+  final val ANDtype = 165
+  final val ANDtpt = 166
+  final val ORtype = 167
+  final val ORtpt = 168
+  final val POLYtype = 169
+  final val TYPELAMBDAtype = 170
+  final val LAMBDAtpt = 171
+  final val PARAMtype = 172
+  final val ANNOTATION = 173
+  final val TERMREFin = 174
+  final val TYPEREFin = 175
+  final val OBJECTDEF = 176
 
   // In binary: 101101EI
   // I = implicit method type
@@ -456,6 +460,7 @@ object TastyFormat {
        | LAZY
        | OVERRIDE
        | INLINE
+       | INLINEPROXY
        | MACRO
        | STATIC
        | OBJECT
@@ -512,6 +517,7 @@ object TastyFormat {
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
     case INLINE => "INLINE"
+    case INLINEPROXY => "INLINEPROXY"
     case MACRO => "MACRO"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
@@ -579,6 +585,7 @@ object TastyFormat {
     case MATCH => "MATCH"
     case RETURN => "RETURN"
     case WHILE => "WHILE"
+    case INLINED => "INLINED"
     case SELECTouter => "SELECTouter"
     case TRY => "TRY"
     case REPEATED => "REPEATED"

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

@@ -442,6 +442,17 @@ class TreePickler(pickler: TastyPickler) {
         case SeqLiteral(elems, elemtpt) =>
           writeByte(REPEATED)
           withLength { pickleTree(elemtpt); elems.foreach(pickleTree) }
+        case Inlined(call, bindings, expansion) =>
+          writeByte(INLINED)
+          bindings.foreach(preRegister)
+          withLength {
+            pickleTree(expansion)
+            if (!call.isEmpty) pickleTree(call)
+            bindings.foreach { b =>
+              assert(b.isInstanceOf[DefDef] || b.isInstanceOf[ValDef])
+              pickleTree(b)
+            }
+          }
         case Bind(name, body) =>
           registerDef(tree.symbol)
           writeByte(BIND)
@@ -608,6 +619,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Case) writeByte(CASE)
     if (flags is Override) writeByte(OVERRIDE)
     if (flags is Inline) writeByte(INLINE)
+    if (flags is InlineProxy) writeByte(INLINEPROXY)
     if (flags is Macro) writeByte(MACRO)
     if (flags is JavaStatic) writeByte(STATIC)
     if (flags is Module) writeByte(OBJECT)

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

@@ -604,6 +604,7 @@ class TreeUnpickler(reader: TastyReader,
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
           case INLINE => addFlag(Inline)
+          case INLINEPROXY => addFlag(InlineProxy)
           case MACRO => addFlag(Macro)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
@@ -1072,6 +1073,17 @@ class TreeUnpickler(reader: TastyReader,
               val stats = readStats(ctx.owner, end)
               val expr = exprReader.readTerm()
               Block(stats, expr)
+            case INLINED =>
+              val exprReader = fork
+              skipTree()
+              def maybeCall = nextUnsharedTag match {
+                case VALDEF | DEFDEF => EmptyTree
+                case _ => readTerm()
+              }
+              val call = ifBefore(end)(maybeCall, EmptyTree)
+              val bindings = readStats(ctx.owner, end).asInstanceOf[List[ValOrDefDef]]
+              val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
+              Inlined(call, bindings, expansion)
             case IF =>
               If(readTerm(), readTerm(), readTerm())
             case LAMBDA =>

compiler/src/dotty/tools/dotc/decompiler/TASTYDecompiler.scala

@@ -15,7 +15,6 @@ class TASTYDecompiler extends TASTYCompiler {
     Nil
 
   override protected def picklerPhases: List[List[Phase]] = Nil
-
   override protected def transformPhases: List[List[Phase]] = Nil
 
   override protected def backendPhases: List[List[Phase]] =

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -40,7 +40,8 @@ object PostTyper {
  *
  *  (10) Adds Child annotations to all sealed classes
  *
- *  (11) Replace RHS of `erased` (but not `inline`) members by `(???: rhs.type)`
+ *  (11) Minimizes `call` fields of `Inlined` nodes to just point to the toplevel
+ *       class from which code was inlined.
  *
  *  The reason for making this a macro transform is that some functions (in particular
  *  super and protected accessors and instantiation checks) are naturally top-down and
@@ -177,22 +178,23 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       }
     }
 
-    private def handleInlineCall(sym: Symbol)(implicit ctx: Context): Unit = {
-      if (sym.is(Inline))
-        ctx.compilationUnit.needsStaging = true
+    private object dropInlines extends TreeMap {
+      override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+        case Inlined(call, _, _) =>
+          cpy.Inlined(tree)(call, Nil, Typed(ref(defn.Predef_undefined), TypeTree(tree.tpe)))
+        case _ => super.transform(tree)
+      }
     }
 
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
-          handleInlineCall(tree.symbol)
           handleMeta(tree.symbol)
           tree.tpe match {
             case tpe: ThisType => This(tpe.cls).withPos(tree.pos)
             case _ => tree
           }
         case tree @ Select(qual, name) =>
-          handleInlineCall(tree.symbol)
           handleMeta(tree.symbol)
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.pos.focus)
@@ -201,15 +203,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           else
             transformSelect(tree, Nil)
         case tree: Apply =>
-          handleInlineCall(tree.symbol)
           val methType = tree.fun.tpe.widen
           val app =
             if (methType.isErasedMethod)
               tpd.cpy.Apply(tree)(
                 tree.fun,
                 tree.args.map(arg =>
                   if (methType.isImplicitMethod && arg.pos.isSynthetic) ref(defn.Predef_undefined)
-                  else arg))
+                  else dropInlines.transform(arg)))
             else
               tree
           methPart(app) match {
@@ -222,7 +223,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               super.transform(app)
           }
         case tree: TypeApply =>
-          handleInlineCall(tree.symbol)
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor) {
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
@@ -236,6 +236,19 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             case _ =>
               super.transform(tree1)
           }
+        case Inlined(call, bindings, expansion) if !call.isEmpty =>
+          // Leave only a call trace consisting of
+          //  - a reference to the top-level class from which the call was inlined,
+          //  - the call's position
+          // in the call field of an Inlined node.
+          // The trace has enough info to completely reconstruct positions.
+          // The minimization is done for two reasons:
+          //  1. To save space (calls might contain large inline arguments, which would otherwise
+          //     be duplicated
+          //  2. To enable correct pickling (calls can share symbols with the inlined code, which
+          //     would trigger an assertion when pickling).
+          val callTrace = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
+          cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(inlineContext(call)))
         case tree: Template =>
           withNoCheckNews(tree.parents.flatMap(newPart)) {
             val templ1 = paramFwd.forwardParamAccessors(tree)
@@ -322,10 +335,9 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       }
 
     /** Transforms the rhs tree into a its default tree if it is in an `erased` val/def.
-     *  Performed to shrink the tree that is known to be erased later.
-     */
+    *  Performed to shrink the tree that is known to be erased later.
+    */
     private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(implicit ctx: Context) =
-      if (!sym.isEffectivelyErased || sym.isInlineMethod || !rhs.tpe.exists) rhs
-      else Typed(ref(defn.Predef_undefined), TypeTree(rhs.tpe))
+      if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
   }
 }