Put position check into a phase

Author: nicolasstucki

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

@@ -37,6 +37,7 @@ class Compiler {
   /** Phases dealing with the frontend up to trees ready for TASTY pickling */
   protected def frontendPhases: List[List[Phase]] =
     List(new FrontEnd) ::           // Compiler frontend: scanner, parser, namer, typer
+    List(new YCheckPositions) ::    // YCheck positions
     List(new Staging) ::            // Check PCP, heal quoted types and expand macros
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new PostTyper) ::          // Additional checks and cleanups after type checking

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

@@ -62,44 +62,6 @@ 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 = {
-              assert(ctx.source == sources.head)
-              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/transform/YCheckPositions.scala

@@ -0,0 +1,64 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Phases
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.util.{SourceFile, SourcePosition}
+
+/** Ycheck inlined positions */
+class YCheckPositions extends Phases.Phase {
+  import tpd._
+
+  def phaseName: String = "inlinedPositions"
+
+  override def run(implicit ctx: Context): Unit = () // YCheck only
+
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
+    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 = {
+
+            // Check current context is correct
+            assert(ctx.source == sources.head)
+            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")
+              }
+            }
+
+            // Recursivlely check children while keeping track of current source
+            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 _ =>
+    }
+
+  }
+
+}

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

@@ -415,7 +415,7 @@ 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)
+      Inlined(EmptyTree, Nil, tree)(ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)
 
     // A tree type map to prepare the inlined body for typechecked.
     // The translation maps references to `this` and parameters to