Use tree checker for macro expanded trees

Trees are only checked if -Xcheck-macros is enabled.

Author: nicolasstucki

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

@@ -816,6 +816,7 @@ class Inliner(val call: tpd.Tree)(using Context):
                         && StagingContext.level == 0
                         && !hasInliningErrors =>
           val expanded = expandMacro(res.args.head, tree.srcPos)
+          transform.TreeChecker.checkMacroGeneratedTree(res, expanded)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
         case res =>
           specializeEq(inlineIfNeeded(res, pt, locked))

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

@@ -82,8 +82,9 @@ class MacroAnnotations(thisPhase: DenotTransformer):
             case (prefixed, newTree :: suffixed) =>
               allTrees ++= prefixed
               insertedAfter = suffixed :: insertedAfter
-              prefixed.foreach(checkAndEnter(_, tree.symbol, annot))
-              suffixed.foreach(checkAndEnter(_, tree.symbol, annot))
+              prefixed.foreach(checkAndEnter(_, tree, annot))
+              suffixed.foreach(checkAndEnter(_, tree, annot))
+              transform.TreeChecker.checkMacroGeneratedTree(tree, newTree)
               newTree
             case (Nil, Nil) =>
               report.error(i"Unexpected `Nil` returned by `(${annot.tree}).transform(..)` during macro expansion", annot.tree.srcPos)
@@ -119,15 +120,17 @@ class MacroAnnotations(thisPhase: DenotTransformer):
     annotInstance.transform(using quotes)(tree.asInstanceOf[quotes.reflect.Definition])
 
   /** Check that this tree can be added by the macro annotation and enter it if needed */
-  private def checkAndEnter(newTree: Tree, annotated: Symbol, annot: Annotation)(using Context) =
+  private def checkAndEnter(newTree: Tree, annotated: Tree, annot: Annotation)(using Context) =
+    transform.TreeChecker.checkMacroGeneratedTree(annotated, newTree)
     val sym = newTree.symbol
+    val annotatedSym = annotated.symbol
     if sym.isClass then
       report.error(i"macro annotation returning a `class` is not yet supported. $annot tried to add $sym", annot.tree)
     else if sym.isType then
       report.error(i"macro annotation cannot return a `type`. $annot tried to add $sym", annot.tree)
-    else if sym.owner != annotated.owner then
-      report.error(i"macro annotation $annot added $sym with an inconsistent owner. Expected it to be owned by ${annotated.owner} but was owned by ${sym.owner}.", annot.tree)
-    else if annotated.isClass && annotated.owner.is(Package) /*&& !sym.isClass*/ then
+    else if sym.owner != annotatedSym.owner then
+      report.error(i"macro annotation $annot added $sym with an inconsistent owner. Expected it to be owned by ${annotatedSym.owner} but was owned by ${sym.owner}.", annot.tree)
+    else if annotatedSym.isClass && annotatedSym.owner.is(Package) /*&& !sym.isClass*/ then
       report.error(i"macro annotation can not add top-level ${sym.showKind}. $annot tried to add $sym.", annot.tree)
     else
       sym.enteredAfter(thisPhase)

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

@@ -167,28 +167,6 @@ class TreeChecker extends Phase with SymTransformer {
 }
 
 object TreeChecker {
-  /** - Check that TypeParamRefs and MethodParams refer to an enclosing type.
-   *  - Check that all type variables are instantiated.
-   */
-  def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(using Context): Type = new TypeMap() {
-    val definedBinders = new java.util.IdentityHashMap[Type, Any]
-    def apply(tp: Type): Type = {
-      tp match {
-        case tp: BindingType =>
-          definedBinders.put(tp, tp)
-          mapOver(tp)
-          definedBinders.remove(tp)
-        case tp: ParamRef =>
-          assert(definedBinders.get(tp.binder) != null, s"orphan param: ${tp.show}, hash of binder = ${System.identityHashCode(tp.binder)}, tree = ${tree.show}, type = $tp0")
-        case tp: TypeVar =>
-          assert(tp.isInstantiated, s"Uninstantiated type variable: ${tp.show}, tree = ${tree.show}")
-          apply(tp.underlying)
-        case _ =>
-          mapOver(tp)
-      }
-      tp
-    }
-  }.apply(tp0)
 
   /** Run some additional checks on the nodes of the trees.  Specifically:
    *
@@ -219,7 +197,7 @@ object TreeChecker {
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
     import ast.tpd._
 
-    private val nowDefinedSyms = util.HashSet[Symbol]()
+    protected val nowDefinedSyms = util.HashSet[Symbol]()
     private val patBoundSyms = util.HashSet[Symbol]()
     private val everDefinedSyms = MutableSymbolMap[untpd.Tree]()
 
@@ -723,5 +701,72 @@ object TreeChecker {
     }
 
     override def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = tree
+
+    /** - Check that TypeParamRefs and MethodParams refer to an enclosing type.
+     *  - Check that all type variables are instantiated.
+     */
+    def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(using Context): Type = new TypeMap() {
+      val definedBinders = new java.util.IdentityHashMap[Type, Any]
+      def apply(tp: Type): Type = {
+        tp match {
+          case tp: BindingType =>
+            definedBinders.put(tp, tp)
+            mapOver(tp)
+            definedBinders.remove(tp)
+          case tp: ParamRef =>
+            assert(definedBinders.get(tp.binder) != null, s"orphan param: ${tp.show}, hash of binder = ${System.identityHashCode(tp.binder)}, tree = ${tree.show}, type = $tp0")
+          case tp: TypeVar =>
+            assert(tp.isInstantiated, s"Uninstantiated type variable: ${tp.show}, tree = ${tree.show}")
+            apply(tp.underlying)
+          case _ =>
+            mapOver(tp)
+        }
+        tp
+      }
+    }.apply(tp0)
   }
+
+  /** Tree checker that can be applied to a local tree. */
+  class LocalChecker(phasesToCheck: Seq[Phase]) extends Checker(phasesToCheck: Seq[Phase]) {
+    override def assertDefined(tree: untpd.Tree)(using Context): Unit =
+      // Only check definitions nested in the local tree
+      if nowDefinedSyms.contains(tree.symbol.maybeOwner) then
+        super.assertDefined(tree)
+
+    override def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(using Context): Type =
+      // TODO: Is this fails on tests/run-macros/quoted-ToExpr-derivation-macro.
+      //       Is this a bug?
+      tp0 // Do not check for orphans
+  }
+
+  def checkMacroGeneratedTree(original: tpd.Tree, expansion: tpd.Tree)(using Context): Unit =
+    if ctx.settings.XcheckMacros.value then
+      val checkingCtx = ctx
+        .fresh
+        .addMode(Mode.ImplicitsEnabled)
+        .setReporter(new ThrowingReporter(ctx.reporter))
+
+      val treeChecker =
+        new LocalChecker(Nil) // TODO enable previous phase post-conditions
+
+      try treeChecker.typed(expansion)(using checkingCtx)
+      catch
+        case err: java.lang.AssertionError =>
+          report.error(
+            em"""Malformed tree was found while expanding macro with -Xcheck-macros.
+                |The tree does not conform to the compiler's tree invariants.
+                |
+                |Macro was:
+                |${original}
+                |
+                |The macro returned:
+                |${expansion}
+                |
+                |Error:
+                |${err.getMessage}
+                |
+                |""",
+            original
+          )
+
 }

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -298,7 +298,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object ValDef extends ValDefModule:
       def apply(symbol: Symbol, rhs: Option[Term]): ValDef =
-        tpd.ValDef(symbol.asTerm, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree))
+        withDefaultPos(tpd.ValDef(symbol.asTerm, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree)))
       def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef =
         tpd.cpy.ValDef(original)(name.toTermName, tpt, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), original.symbol).getOrElse(tpd.EmptyTree))
       def unapply(vdef: ValDef): (String, TypeTree, Option[Term]) =
@@ -1474,7 +1474,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Bind extends BindModule:
       def apply(sym: Symbol, pattern: Tree): Bind =
-        tpd.Bind(sym, pattern)
+        withDefaultPos(tpd.Bind(sym, pattern))
       def copy(original: Tree)(name: String, pattern: Tree): Bind =
         withDefaultPos(tpd.cpy.Bind(original)(name.toTermName, pattern))
       def unapply(pattern: Bind): (String, Tree) =