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

@@ -219,7 +219,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 +724,42 @@ 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 treeChecker =
+        new LocalChecker(Nil) // TODO enable previous phase post-conditions
+
+      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
+          )
+
 }

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,10 @@ 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)
+        val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span)
+        import tpd.TreeOps
+        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](???)