Use tree checker for macro expanded trees

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

Fixes:
 - Add missing positions to {ValDef,Bind}.apply
 - Inline by-name ascribed param
 - Unbound type variables after implicit search

Author: nicolasstucki

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

@@ -227,7 +227,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     val binding = {
       var newArg = arg.changeOwner(ctx.owner, boundSym)
       if bindingFlags.is(Inline) && argIsBottom then
-        newArg = Typed(newArg, TypeTree(formal)) // type ascribe RHS to avoid type errors in expansion. See i8612.scala
+        newArg = Typed(newArg, TypeTree(formal.widenExpr)) // type ascribe RHS to avoid type errors in expansion. See i8612.scala
       if isByName then DefDef(boundSym, newArg)
       else ValDef(boundSym, newArg)
     }.withSpan(boundSym.span)
@@ -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,8 +120,10 @@ 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, annotatedTree: Tree, annot: Annotation)(using Context) =
+    transform.TreeChecker.checkMacroGeneratedTree(annotatedTree, newTree)
     val sym = newTree.symbol
+    val annotated = annotatedTree.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

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

@@ -105,18 +105,6 @@ class TreeChecker extends Phase with SymTransformer {
     else if (ctx.phase.prev.isCheckable)
       check(ctx.base.allPhases.toIndexedSeq, ctx)
 
-  private def previousPhases(phases: List[Phase])(using Context): List[Phase] = phases match {
-    case (phase: MegaPhase) :: phases1 =>
-      val subPhases = phase.miniPhases
-      val previousSubPhases = previousPhases(subPhases.toList)
-      if (previousSubPhases.length == subPhases.length) previousSubPhases ::: previousPhases(phases1)
-      else previousSubPhases
-    case phase :: phases1 if phase ne ctx.phase =>
-      phase :: previousPhases(phases1)
-    case _ =>
-      Nil
-  }
-
   def check(phasesToRun: Seq[Phase], ctx: Context): Tree = {
     val fusedPhase = ctx.phase.prevMega(using ctx)
     report.echo(s"checking ${ctx.compilationUnit} after phase ${fusedPhase}")(using ctx)
@@ -219,7 +207,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]()
 
@@ -724,4 +712,52 @@ object TreeChecker {
 
     override def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = tree
   }
+
+  /** 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)
+
+  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 phases = ctx.base.allPhases.toList
+      val treeChecker = new LocalChecker(previousPhases(phases))
+
+      try treeChecker.typed(expansion)(using checkingCtx)
+      catch
+        case err: java.lang.AssertionError =>
+          report.error(
+            s"""Malformed tree was found while expanding macro with -Xcheck-macros.
+               |The tree does not conform to the compiler's tree invariants.
+               |
+               |Macro was:
+               |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(original)}
+               |
+               |The macro returned:
+               |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(expansion)}
+               |
+               |Error:
+               |${err.getMessage}
+               |
+               |""",
+            original
+          )
+
+  private[TreeChecker] def previousPhases(phases: List[Phase])(using Context): List[Phase] = phases match {
+    case (phase: MegaPhase) :: phases1 =>
+      val subPhases = phase.miniPhases
+      val previousSubPhases = previousPhases(subPhases.toList)
+      if (previousSubPhases.length == subPhases.length) previousSubPhases ::: previousPhases(phases1)
+      else previousSubPhases
+    case phase :: phases1 if phase ne ctx.phase =>
+      phase :: previousPhases(phases1)
+    case _ =>
+      Nil
+  }
 }

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) =
@@ -2395,7 +2395,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Implicits extends ImplicitsModule:
       def search(tpe: TypeRepr): ImplicitSearchResult =
-        ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span)
+        import tpd.TreeOps
+        val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span)
+        // Make sure that we do not have any uninstantiated type variables.
+        // See tests/pos-macros/exprSummonWithTypeVar with -Xcheck-macros.
+        implicitTree.foreachSubTree(tree => dotc.typer.Inferencing.fullyDefinedType(tree.tpe, "", tree))
+        implicitTree
     end Implicits
 
     type ImplicitSearchResult = Tree

tests/pos-macros/exprSummonWithTypeVar/Macro_1.scala

@@ -0,0 +1,13 @@
+import scala.compiletime.{erasedValue, summonFrom}
+
+import scala.quoted._
+
+inline given summonAfterTypeMatch[T]: Any =
+  ${ summonAfterTypeMatchExpr[T] }
+
+private def summonAfterTypeMatchExpr[T: Type](using Quotes): Expr[Any] =
+  Expr.summon[Foo[T]].get
+
+trait Foo[T]
+
+given IntFoo[T <: Int]: Foo[T] = ???

tests/pos-macros/exprSummonWithTypeVar/Test_2.scala

@@ -0,0 +1 @@
+def test: Unit = summonAfterTypeMatch[Int]

tests/pos-macros/macro-inline-by-name-cast/Macro_1.scala

@@ -0,0 +1,7 @@
+import scala.quoted.*
+
+inline def f[T](inline code: =>T): Any =
+  ${ create[T]('{ () => code }) }
+
+def create[T: Type](code: Expr[() => T])(using Quotes): Expr[Any] =
+  '{ identity($code) }

tests/pos-macros/macro-inline-by-name-cast/Test_2.scala

@@ -0,0 +1 @@
+def test: Unit = f[Unit](???)