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(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

@@ -84,6 +84,7 @@ class MacroAnnotations(thisPhase: DenotTransformer):
               insertedAfter = suffixed :: insertedAfter
               prefixed.foreach(checkAndEnter(_, tree.symbol, annot))
               suffixed.foreach(checkAndEnter(_, tree.symbol, annot))
+              transform.TreeChecker.checkMacroGeneratedTree(newTree)
               newTree
             case (Nil, Nil) =>
               report.error(i"Unexpected `Nil` returned by `(${annot.tree}).transform(..)` during macro expansion", annot.tree.srcPos)
@@ -120,6 +121,7 @@ class MacroAnnotations(thisPhase: DenotTransformer):
 
   /** 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) =
+    transform.TreeChecker.checkMacroGeneratedTree(newTree)
     val sym = newTree.symbol
     if sym.isClass then
       report.error(i"macro annotation returning a `class` is not yet supported. $annot tried to add $sym", annot.tree)

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:
    *
@@ -723,5 +701,94 @@ 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)
   }
+
+  class LocalChecker(phasesToCheck: Seq[Phase]) extends Checker(phasesToCheck: Seq[Phase]) {
+    override def assertDefined(tree: untpd.Tree)(using Context): Unit =
+      () // TODO check locally defined symbols
+      // if (tree.symbol.maybeOwner.isTerm) {
+      //   val sym = tree.symbol
+      //   assert(
+      //     nowDefinedSyms.contains(sym) || patBoundSyms.contains(sym),
+      //     i"undefined symbol ${sym} at line " + tree.srcPos.line
+      //   )
+
+      //   if (!ctx.phase.patternTranslated)
+      //     assert(
+      //       !sym.isPatternBound || patBoundSyms.contains(sym),
+      //       i"sym.isPatternBound => patBoundSyms.contains(sym) is broken, sym = $sym, line " + tree.srcPos.line
+      //     )
+      // }
+
+    /** - Check that TypeParamRefs and MethodParams refer to an enclosing type.
+     */
+    override def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(using Context): Type =
+      tp0 // Can we check part of this?
+      //   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)
+  }
+
+  def checkMacroGeneratedTree(tree: tpd.Tree)(using Context): Unit =
+    if ctx.settings.XcheckMacros.value then
+      val checkingCtx = ctx
+        .fresh
+        .addMode(Mode.ImplicitsEnabled)
+        .setReporter(new ThrowingReporter(ctx.reporter)) // TODO report as errors
+      val treeChecker = new LocalChecker(Nil) // TODO enable previous phase post-conditions
+      try treeChecker.typed(tree)(using checkingCtx)
+      catch
+        case err: java.lang.AssertionError =>
+          report.error(
+            em"""Malformed tree was found while expanding macro with -Xcheck-macros.
+                |
+                |The tree returned by the macro was:
+                |${tree}
+                |
+                |Error:
+                |${err.getMessage}
+                |
+                |""",
+            tree
+          )
+
 }

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) =