Add Inlined tree node

... to tag inlined calls. Perform typings and transformations
of inlined calls in a context that refers to the INlined node
in its InlinedCall property.

The idea is that we can use this to issue better error
positions. This remains to be implemented.

10 files changed, 94 insertions, 5 deletions

diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index 2120fa73e..178cba7c4 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -94,6 +94,7 @@ class Compiler {
            new SelectStatic,        // get rid of selects that would be compiled into GetStatic
            new CollectEntryPoints,  // Find classes with main methods
            new CollectSuperCalls,   // Find classes that are called with super
+           new DropInlined,         // Drop Inlined nodes, since backend has no use for them
            new MoveStatics,         // Move static methods to companion classes
            new LabelDefs),          // Converts calls to labels to jumps
       List(new GenSJSIR),           // Generate .js code
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 3b5de9308..fca1c1500 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -503,6 +503,12 @@ object Trees {
     override def toString = s"JavaSeqLiteral($elems, $elemtpt)"
   }
 
+  /** Inlined code */
+  case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = Inlined[T]
+    }
+
   /** A type tree that represents an existing or inferred type */
   case class TypeTree[-T >: Untyped] private[ast] (original: Tree[T])
     extends DenotingTree[T] with TypTree[T] {
@@ -797,6 +803,7 @@ object Trees {
     type Try = Trees.Try[T]
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
+    type Inlined = Trees.Inlined[T]
     type TypeTree = Trees.TypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
     type AndTypeTree = Trees.AndTypeTree[T]
@@ -939,6 +946,10 @@ object Trees {
         case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
         case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt))
       }
+      def Inlined(tree: Tree)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit ctx: Context): Inlined = tree match {
+        case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
+        case _ => finalize(tree, untpd.Inlined(call, bindings, expansion))
+      }
       def TypeTree(tree: Tree)(original: Tree): TypeTree = tree match {
         case tree: TypeTree if original eq tree.original => tree
         case _ => finalize(tree, untpd.TypeTree(original))
@@ -1083,6 +1094,8 @@ object Trees {
           cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
         case SeqLiteral(elems, elemtpt) =>
           cpy.SeqLiteral(tree)(transform(elems), transform(elemtpt))
+        case Inlined(call, bindings, expansion) =>
+          cpy.Inlined(tree)(call, transformSub(bindings), transform(expansion))
         case TypeTree(original) =>
           tree
         case SingletonTypeTree(ref) =>
@@ -1185,6 +1198,8 @@ object Trees {
             this(this(this(x, block), handler), finalizer)
           case SeqLiteral(elems, elemtpt) =>
             this(this(x, elems), elemtpt)
+          case Inlined(call, bindings, expansion) =>
+            this(this(x, bindings), expansion)
           case TypeTree(original) =>
             x
           case SingletonTypeTree(ref) =>
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index f59bb7a47..dc0756df1 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -116,6 +116,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): JavaSeqLiteral =
     ta.assignType(new untpd.JavaSeqLiteral(elems, elemtpt), elems, elemtpt).asInstanceOf[JavaSeqLiteral]
 
+  def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(implicit ctx: Context): Inlined =
+    untpd.Inlined(call, bindings, expansion).withType(expansion.tpe)
+
   def TypeTree(original: Tree)(implicit ctx: Context): TypeTree =
     TypeTree(original.tpe, original)
 
diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index 32e27e9c7..114c13684 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -197,6 +197,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Try(expr: Tree, cases: List[CaseDef], finalizer: Tree): Try = new Try(expr, cases, finalizer)
   def SeqLiteral(elems: List[Tree], elemtpt: Tree): SeqLiteral = new SeqLiteral(elems, elemtpt)
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
+  def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree): Inlined = new Inlined(call, bindings, expansion)
   def TypeTree(original: Tree): TypeTree = new TypeTree(original)
   def TypeTree() = new TypeTree(EmptyTree)
   def SingletonTypeTree(ref: Tree): SingletonTypeTree = new SingletonTypeTree(ref)
diff --git a/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index e5cacfc00..fe6a5f828 100644
--- a/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -7,6 +7,7 @@ import ast.Trees._
 import TastyFormat._
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
 import collection.mutable
+import typer.Inliner
 import NameOps._
 import TastyBuffer._
 import TypeApplications._
@@ -430,6 +431,15 @@ class TreePickler(pickler: TastyPickler) {
       case SeqLiteral(elems, elemtpt) =>
         writeByte(REPEATED)
         withLength { pickleTree(elemtpt); elems.foreach(pickleTree) }
+      case tree: Inlined =>
+        // Why drop Inlined info when pickling?
+        // Since we never inline inside an inlined method, we know that
+        // any code that continas an Inlined tree is not inlined itself.
+        // So position information for inline expansion is no longer needed.
+        // The only reason to keep the inline info around would be to have fine-grained
+        // position information in the linker. We should come back to this
+        // point once we know more what we would do with such information.
+        pickleTree(Inliner.dropInlined(tree))
       case TypeTree(original) =>
         pickleTpt(tree)
       case Bind(name, body) =>
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 205d2b6b9..53d9750f8 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -351,6 +351,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case SeqLiteral(elems, elemtpt) =>
         "[" ~ toTextGlobal(elems, ",") ~ " : " ~ toText(elemtpt) ~ "]"
+      case Inlined(call, bindings, body) =>
+        "/* inlined from " ~ toText(call) ~ "*/ " ~ blockText(bindings :+ body)
       case tpt: untpd.DerivedTypeTree =>
         "<derived typetree watching " ~ summarized(toText(tpt.watched)) ~ ">"
       case TypeTree(orig) =>
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index e7342aec9..074a278ca 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -396,6 +396,9 @@ class TreeChecker extends Phase with SymTransformer {
     override def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) =
       withDefinedSyms(tree.stats) { super.typedBlock(tree, pt) }
 
+    override def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context) =
+      withDefinedSyms(tree.bindings) { super.typedInlined(tree, pt) }
+
     /** Check that all defined symbols have legal owners.
      *  An owner is legal if it is either the same as the context's owner
      *  or there's an owner chain of valdefs starting at the context's owner and
diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index 05961508a..40a5cb0bf 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -15,6 +15,7 @@ import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.util.DotClass
+import dotty.tools.dotc.typer.Inliner
 import scala.annotation.tailrec
 import config.Printers.transforms
 import scala.util.control.NonFatal
@@ -81,6 +82,7 @@ object TreeTransforms {
     def prepareForReturn(tree: Return)(implicit ctx: Context) = this
     def prepareForTry(tree: Try)(implicit ctx: Context) = this
     def prepareForSeqLiteral(tree: SeqLiteral)(implicit ctx: Context) = this
+    def prepareForInlined(tree: Inlined)(implicit ctx: Context) = this
     def prepareForTypeTree(tree: TypeTree)(implicit ctx: Context) = this
     def prepareForBind(tree: Bind)(implicit ctx: Context) = this
     def prepareForAlternative(tree: Alternative)(implicit ctx: Context) = this
@@ -112,6 +114,7 @@ object TreeTransforms {
     def transformReturn(tree: Return)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformTry(tree: Try)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformSeqLiteral(tree: SeqLiteral)(implicit ctx: Context, info: TransformerInfo): Tree = tree
+    def transformInlined(tree: Inlined)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformTypeTree(tree: TypeTree)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformBind(tree: Bind)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformAlternative(tree: Alternative)(implicit ctx: Context, info: TransformerInfo): Tree = tree
@@ -273,6 +276,7 @@ object TreeTransforms {
       nxPrepReturn = index(transformations, "prepareForReturn")
       nxPrepTry = index(transformations, "prepareForTry")
       nxPrepSeqLiteral = index(transformations, "prepareForSeqLiteral")
+      nxPrepInlined = index(transformations, "prepareForInlined")
       nxPrepTypeTree = index(transformations, "prepareForTypeTree")
       nxPrepBind = index(transformations, "prepareForBind")
       nxPrepAlternative = index(transformations, "prepareForAlternative")
@@ -303,6 +307,7 @@ object TreeTransforms {
       nxTransReturn = index(transformations, "transformReturn")
       nxTransTry = index(transformations, "transformTry")
       nxTransSeqLiteral = index(transformations, "transformSeqLiteral")
+      nxTransInlined = index(transformations, "transformInlined")
       nxTransTypeTree = index(transformations, "transformTypeTree")
       nxTransBind = index(transformations, "transformBind")
       nxTransAlternative = index(transformations, "transformAlternative")
@@ -343,6 +348,7 @@ object TreeTransforms {
       nxPrepReturn = indexUpdate(prev.nxPrepReturn, changedTransformationClass, transformationIndex, "prepareForReturn", copy)
       nxPrepTry = indexUpdate(prev.nxPrepTry, changedTransformationClass, transformationIndex, "prepareForTry", copy)
       nxPrepSeqLiteral = indexUpdate(prev.nxPrepSeqLiteral, changedTransformationClass, transformationIndex, "prepareForSeqLiteral", copy)
+      nxPrepInlined = indexUpdate(prev.nxPrepInlined, changedTransformationClass, transformationIndex, "prepareForInlined", copy)
       nxPrepTypeTree = indexUpdate(prev.nxPrepTypeTree, changedTransformationClass, transformationIndex, "prepareForTypeTree", copy)
       nxPrepBind = indexUpdate(prev.nxPrepBind, changedTransformationClass, transformationIndex, "prepareForBind", copy)
       nxPrepAlternative = indexUpdate(prev.nxPrepAlternative, changedTransformationClass, transformationIndex, "prepareForAlternative", copy)
@@ -372,6 +378,7 @@ object TreeTransforms {
       nxTransReturn = indexUpdate(prev.nxTransReturn, changedTransformationClass, transformationIndex, "transformReturn", copy)
       nxTransTry = indexUpdate(prev.nxTransTry, changedTransformationClass, transformationIndex, "transformTry", copy)
       nxTransSeqLiteral = indexUpdate(prev.nxTransSeqLiteral, changedTransformationClass, transformationIndex, "transformSeqLiteral", copy)
+      nxTransInlined = indexUpdate(prev.nxTransInlined, changedTransformationClass, transformationIndex, "transformInlined", copy)
       nxTransTypeTree = indexUpdate(prev.nxTransTypeTree, changedTransformationClass, transformationIndex, "transformTypeTree", copy)
       nxTransBind = indexUpdate(prev.nxTransBind, changedTransformationClass, transformationIndex, "transformBind", copy)
       nxTransAlternative = indexUpdate(prev.nxTransAlternative, changedTransformationClass, transformationIndex, "transformAlternative", copy)
@@ -407,6 +414,7 @@ object TreeTransforms {
     var nxPrepReturn: Array[Int] = _
     var nxPrepTry: Array[Int] = _
     var nxPrepSeqLiteral: Array[Int] = _
+    var nxPrepInlined: Array[Int] = _
     var nxPrepTypeTree: Array[Int] = _
     var nxPrepBind: Array[Int] = _
     var nxPrepAlternative: Array[Int] = _
@@ -437,6 +445,7 @@ object TreeTransforms {
     var nxTransReturn: Array[Int] = _
     var nxTransTry: Array[Int] = _
     var nxTransSeqLiteral: Array[Int] = _
+    var nxTransInlined: Array[Int] = _
     var nxTransTypeTree: Array[Int] = _
     var nxTransBind: Array[Int] = _
     var nxTransAlternative: Array[Int] = _
@@ -515,6 +524,7 @@ object TreeTransforms {
     val prepForReturn: Mutator[Return] = (trans, tree, ctx) => trans.prepareForReturn(tree)(ctx)
     val prepForTry: Mutator[Try] = (trans, tree, ctx) => trans.prepareForTry(tree)(ctx)
     val prepForSeqLiteral: Mutator[SeqLiteral] = (trans, tree, ctx) => trans.prepareForSeqLiteral(tree)(ctx)
+    val prepForInlined: Mutator[Inlined] = (trans, tree, ctx) => trans.prepareForInlined(tree)(ctx)
     val prepForTypeTree: Mutator[TypeTree] = (trans, tree, ctx) => trans.prepareForTypeTree(tree)(ctx)
     val prepForBind: Mutator[Bind] = (trans, tree, ctx) => trans.prepareForBind(tree)(ctx)
     val prepForAlternative: Mutator[Alternative] = (trans, tree, ctx) => trans.prepareForAlternative(tree)(ctx)
@@ -741,6 +751,17 @@ object TreeTransforms {
     }
 
     @tailrec
+    final private[TreeTransforms] def goInlined(tree: Inlined, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
+      if (cur < info.transformers.length) {
+        val trans = info.transformers(cur)
+        trans.transformInlined(tree)(ctx.withPhase(trans.treeTransformPhase), info) match {
+          case t: Inlined => goInlined(t, info.nx.nxTransInlined(cur + 1))
+          case t => transformSingle(t, cur + 1)
+        }
+      } else tree
+    }
+
+    @tailrec
     final private[TreeTransforms] def goTypeTree(tree: TypeTree, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
       if (cur < info.transformers.length) {
         val trans = info.transformers(cur)
@@ -884,7 +905,8 @@ object TreeTransforms {
         case tree: CaseDef => goCaseDef(tree, info.nx.nxTransCaseDef(cur))
         case tree: Return => goReturn(tree, info.nx.nxTransReturn(cur))
         case tree: Try => goTry(tree, info.nx.nxTransTry(cur))
-        case tree: SeqLiteral => goSeqLiteral(tree, info.nx.nxTransLiteral(cur))
+        case tree: SeqLiteral => goSeqLiteral(tree, info.nx.nxTransSeqLiteral(cur))
+        case tree: Inlined => goInlined(tree, info.nx.nxTransInlined(cur))
         case tree: TypeTree => goTypeTree(tree, info.nx.nxTransTypeTree(cur))
         case tree: Alternative => goAlternative(tree, info.nx.nxTransAlternative(cur))
         case tree: UnApply => goUnApply(tree, info.nx.nxTransUnApply(cur))
@@ -1090,6 +1112,14 @@ object TreeTransforms {
             val elemtpt = transform(tree.elemtpt, mutatedInfo, cur)
             goSeqLiteral(cpy.SeqLiteral(tree)(elems, elemtpt), mutatedInfo.nx.nxTransSeqLiteral(cur))
           }
+        case tree: Inlined =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForInlined, info.nx.nxPrepInlined, tree, cur)
+          if (mutatedInfo eq null) tree
+          else {
+            val bindings = transformSubTrees(tree.bindings, mutatedInfo, cur)
+            val expansion = transform(tree.expansion, mutatedInfo, cur)(Inliner.inlineContext(tree))
+            goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), mutatedInfo.nx.nxTransInlined(cur))
+          }
         case tree: TypeTree =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeTree, info.nx.nxPrepTypeTree, tree, cur)
           if (mutatedInfo eq null) tree
diff --git a/src/dotty/tools/dotc/typer/Inliner.scala b/src/dotty/tools/dotc/typer/Inliner.scala
index 4eb8588a6..51efca3f4 100644
--- a/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/src/dotty/tools/dotc/typer/Inliner.scala
@@ -30,6 +30,8 @@ object Inliner {
 
   private val InlinedBody = new Property.Key[InlinedBody] // to be used as attachment
 
+  val InlinedCall = new Property.Key[tpd.Inlined] // to be used in context
+
   def attachBody(inlineAnnot: Annotation, tree: => Tree)(implicit ctx: Context): Unit =
     inlineAnnot.tree.putAttachment(InlinedBody, new InlinedBody(tree))
 
@@ -68,6 +70,17 @@ object Inliner {
                    | Maybe this is caused by a recursive inline method?
                    | You can use -Xmax:inlines to change the limit.""")
   }
+
+  def dropInlined(tree: tpd.Inlined)(implicit ctx: Context): Tree = {
+    val reposition = new TreeMap {
+      override def transform(tree: Tree)(implicit ctx: Context): Tree =
+        tree.withPos(tree.pos)
+    }
+    tpd.seq(tree.bindings, reposition.transform(tree.expansion))
+  }
+
+  def inlineContext(tree: untpd.Inlined)(implicit ctx: Context): Context =
+    ctx.fresh.setProperty(InlinedCall, tree)
 }
 
 class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
@@ -191,8 +204,9 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
     }
 
     val inliner = new TreeTypeMap(typeMap, treeMap, meth :: Nil, ctx.owner :: Nil)
-
-    val result = inliner(Block(outerBindings.toList, rhs)).withPos(call.pos)
+    val Block(bindings: List[MemberDef], expansion) =
+      inliner(Block(outerBindings.toList, rhs)).withPos(call.pos)
+    val result = tpd.Inlined(call, bindings, expansion)
 
     inlining.println(i"inlining $call\n --> \n$result")
     result
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 007eaa468..dc41cc567 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -553,9 +553,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
+  def typedBlockStats(stats: List[untpd.Tree])(implicit ctx: Context): (Context, List[tpd.Tree]) =
+    (index(stats), typedStats(stats, ctx.owner))
+
   def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) = track("typedBlock") {
-    val exprCtx = index(tree.stats)
-    val stats1 = typedStats(tree.stats, ctx.owner)
+    val (exprCtx, stats1) = typedBlockStats(tree.stats)
     val ept =
       if (tree.isInstanceOf[untpd.InfixOpBlock])
         // Right-binding infix operations are expanded to InfixBlocks, which may be followed by arguments.
@@ -943,6 +945,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     assignType(cpy.SeqLiteral(tree)(elems1, elemtpt1), elems1, elemtpt1)
   }
 
+  def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context): Inlined = {
+    val (exprCtx, bindings1) = typedBlockStats(tree.bindings)
+    val expansion1 = typed(tree.expansion, pt)(Inliner.inlineContext(tree)(exprCtx))
+    cpy.Inlined(tree)(tree.call, bindings1.asInstanceOf[List[MemberDef]], expansion1)
+      .withType(expansion1.tpe)
+  }
+
   def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = track("typedTypeTree") {
     if (tree.original.isEmpty)
       tree match {
@@ -1429,6 +1438,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           case tree: untpd.TypeApply => typedTypeApply(tree, pt)
           case tree: untpd.Super => typedSuper(tree, pt)
           case tree: untpd.SeqLiteral => typedSeqLiteral(tree, pt)
+          case tree: untpd.Inlined => typedInlined(tree, pt)
           case tree: untpd.TypeTree => typedTypeTree(tree, pt)
           case tree: untpd.SingletonTypeTree => typedSingletonTypeTree(tree)
           case tree: untpd.AndTypeTree => typedAndTypeTree(tree)