Add inlined invariant assertions and fixes

Author: nicolasstucki

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

@@ -481,6 +481,7 @@ object Contexts {
     }
 
     def typerPhase: Phase                  = base.typerPhase
+    def postTyperPhase: Phase              = base.postTyperPhase
     def sbtExtractDependenciesPhase: Phase = base.sbtExtractDependenciesPhase
     def picklerPhase: Phase                = base.picklerPhase
     def reifyQuotesPhase: Phase            = base.reifyQuotesPhase

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

@@ -217,6 +217,7 @@ object Phases {
     }
 
     private[this] var myTyperPhase: Phase = _
+    private[this] var myPostTyperPhase: Phase = _
     private[this] var mySbtExtractDependenciesPhase: Phase = _
     private[this] var myPicklerPhase: Phase = _
     private[this] var myReifyQuotesPhase: Phase = _
@@ -234,6 +235,7 @@ object Phases {
     private[this] var myGenBCodePhase: Phase = _
 
     final def typerPhase: Phase = myTyperPhase
+    final def postTyperPhase: Phase = myPostTyperPhase
     final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
     final def picklerPhase: Phase = myPicklerPhase
     final def reifyQuotesPhase: Phase = myReifyQuotesPhase
@@ -254,6 +256,7 @@ object Phases {
       def phaseOfClass(pclass: Class[_]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
 
       myTyperPhase = phaseOfClass(classOf[FrontEnd])
+      myPostTyperPhase = phaseOfClass(classOf[PostTyper])
       mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
       myPicklerPhase = phaseOfClass(classOf[Pickler])
       myReifyQuotesPhase = phaseOfClass(classOf[ReifyQuotes])

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

@@ -303,7 +303,14 @@ class ReifyQuotes extends MacroTransform {
 
       val tpe = MethodType(defn.SeqType.appliedTo(defn.AnyType) :: Nil, tree.tpe.widen)
       val meth = ctx.newSymbol(lambdaOwner, UniqueName.fresh(nme.ANON_FUN), Synthetic | Method, tpe)
-      Closure(meth, tss => body(tss.head.head)(ctx.withOwner(meth)).changeOwner(ctx.owner, meth))
+      val closure = Closure(meth, tss => body(tss.head.head)(ctx.withOwner(meth)).changeOwner(ctx.owner, meth)).withSpan(tree.span)
+
+      enclosingInlineds match {
+        case enclosingInline :: _ =>
+         // In case a tree was inlined inside of the quote and we this closure corresponds to code within it we need to keep the inlined node.
+         Inlined(enclosingInline, Nil, closure)(ctx.withSource(lambdaOwner.topLevelClass.source))
+        case Nil => closure
+      }
     }
 
     private def transformWithCapturer(tree: Tree)(capturer: mutable.Map[Symbol, Tree] => Tree => Tree)(implicit ctx: Context): Tree = {

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

@@ -14,8 +14,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.TreePickler.Hole
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.util.SourcePosition
-import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.util.{SourceFile, SourcePosition}
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.transform.TreeMapWithStages._
 import dotty.tools.dotc.typer.Implicits.SearchFailureType
@@ -65,6 +64,43 @@ class Staging extends MacroTransform {
         case _ =>
       }
     }
+    if (ctx.phase <= ctx.erasurePhase) {
+      tree match {
+        case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
+          new TreeTraverser {
+            private[this] var sources: List[SourceFile] = ctx.source :: Nil
+            def traverse(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+              if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable) {
+                if (!tree.isType) { // TODO also check types, currently we do not add Inlined(EmptyTree, _, _) for types. We should.
+                  val currentSource = sources.head
+                  assert(tree.source == currentSource, i"wrong source set for $tree # ${tree.uniqueId} of ${tree.getClass}, set to ${tree.source} but context had $currentSource")
+                }
+              }
+              tree match {
+                case Inlined(EmptyTree, bindings, expansion) =>
+                  assert(bindings.isEmpty)
+                  val old = sources
+                  sources = old.tail
+                  traverse(expansion)(inlineContext(EmptyTree))
+                  sources = old
+                case Inlined(call, bindings, expansion) =>
+                  bindings.foreach(traverse(_))
+                  sources = call.symbol.topLevelClass.source :: sources
+                  if (
+                    !( // FIXME macro implementations can drop Inlined nodes. We should reinsert them after macro expansion based on the positions of the trees
+                      ((ctx.phase <= ctx.typerPhase.next) && call.symbol.is(Macro)) ||
+                      (!(ctx.phase <= ctx.typerPhase.next) && call.symbol.unforcedDecls.exists(_.is(Macro)) || call.symbol.unforcedDecls.toList.exists(_.is(Macro)))
+                    )
+                  ) traverse(expansion)(inlineContext(call))
+                  sources = sources.tail
+                case _ => traverseChildren(tree)
+              }
+            }
+          }.traverse(tree)
+        case _ =>
+      }
+
+    }
   }
 
   override def run(implicit ctx: Context): Unit =

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

@@ -1581,7 +1581,7 @@ final class SearchRoot extends SearchHistory {
             // Substitute dictionary references into dictionary entry RHSs
             val rhsMap = new TreeTypeMap(treeMap = {
               case id: Ident if vsymMap.contains(id.symbol) =>
-                tpd.ref(vsymMap(id.symbol))
+                tpd.ref(vsymMap(id.symbol)).withSpan(id.span)
               case tree => tree
             })
             val nrhss = rhss.map(rhsMap(_))

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

@@ -372,12 +372,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    *  from its `originalOwner`, and, if it comes from outside the inlined method
    *  itself, it has to be marked as an inlined argument.
    */
-  def integrate(tree: Tree, originalOwner: Symbol)(implicit ctx: Context): Tree = {
-    val result = tree.changeOwner(originalOwner, ctx.owner)
-    if (!originalOwner.isContainedIn(inlinedMethod))
-      Inlined(EmptyTree, Nil, result).withSpan(tree.span)
-    else result
-  }
+  def integrate(tree: Tree, originalOwner: Symbol)(implicit ctx: Context): Tree =
+    tree.changeOwner(originalOwner, ctx.owner)
 
   def tryConstValue: Tree =
     ctx.typeComparer.constValue(callTypeArgs.head.tpe) match {
@@ -418,6 +414,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
 
+    def inlinedFromOutside(tree: Tree)(span: Span): Tree =
+      Inlined(EmptyTree, Nil, tree)(inlinedSourceCtx).withSpan(span)
+
     // A tree type map to prepare the inlined body for typechecked.
     // The translation maps references to `this` and parameters to
     // corresponding arguments or proxies on the type and term level. It also changes
@@ -438,7 +437,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           tree.tpe match {
             case thistpe: ThisType =>
               thisProxy.get(thistpe.cls) match {
-                case Some(t) => ref(t).withSpan(tree.span)
+                case Some(t) =>
+                  val thisRef = ref(t).withSpan(call.span)
+                  inlinedFromOutside(thisRef)(tree.span)
                 case None => tree
               }
             case _ => tree
@@ -449,12 +450,11 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
             if (tree.name == nme.WILDCARD) tree.span // From type match
             else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span?
             else paramSpan(tree.name)
+          val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source)
           paramProxy.get(tree.tpe) match {
             case Some(t) if tree.isTerm && t.isSingleton =>
-              t.dealias match {
-                case tp: ConstantType => Inlined(EmptyTree, Nil, singleton(tp).withSpan(argSpan)).withSpan(tree.span)
-                case tp => singleton(tp).withSpan(argSpan)
-              }
+              val inlinedSingleton = singleton(t).withSpan(argSpan)
+              inlinedFromOutside(inlinedSingleton)(tree.span)
             case Some(t) if tree.isType =>
               TypeTree(t).withSpan(argSpan)
             case _ => tree
@@ -467,7 +467,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     // Apply inliner to `rhsToInline`, split off any implicit bindings from result, and
     // make them part of `bindingsBuf`. The expansion is then the tree that remains.
-    val expansion = inliner.transform(rhsToInline).withSpan(call.span)
+    val expansion = inliner.transform(rhsToInline)
 
     def issueError() = callValueArgss match {
       case (msgArg :: rest) :: Nil =>
@@ -979,8 +979,17 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       assert(level == 0)
       val inlinedFrom = enclosingInlineds.last
       val evaluatedSplice = Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)(ctx.withSource(inlinedFrom.source))
+
+      val inlinedNormailizer = new TreeMap {
+        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+          case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)
+          case _ => super.transform(tree)
+        }
+      }
+      val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
+
       if (ctx.reporter.hasErrors) EmptyTree
-      else evaluatedSplice.withSpan(span)
+      else normalizedSplice.withSpan(span)
     }
 
     override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree =
@@ -1159,4 +1168,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       inlineTermBindings(termBindings1.asInstanceOf[List[ValOrDefDef]], tree1)
     }
   }
+
+  private def inlinedSourceCtx(implicit ctx: Context): Context = ctx.withSource(inlinedMethod.topLevelClass.source)
+
 }

tests/run/i4803/App_2.scala

@@ -12,9 +12,9 @@ object Test {
     println(n.power(5))
 
     val n2 = new Num2(1.5)
-    println(n.power(0))
-    println(n.power(1))
-    println(n.power(2))
-    println(n.power(5))
+    println(n2.power(0))
+    println(n2.power(1))
+    println(n2.power(2))
+    println(n2.power(5))
   }
 }