Inlined non-eta-expanded trees message

Closes #11483

Author: nicolasstucki

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

@@ -592,11 +592,15 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Apply extends ApplyModule:
       def apply(fun: Term, args: List[Term]): Apply =
+        yCheckArgs(args)
         withDefaultPos(tpd.Apply(fun, args))
       def copy(original: Tree)(fun: Term, args: List[Term]): Apply =
+        yCheckArgs(args)
         tpd.cpy.Apply(original)(fun, args)
       def unapply(x: Apply): (Term, List[Term]) =
         (x.fun, x.args)
+      private def yCheckArgs(args: List[Term]): Unit =
+        if yCheck then args.foreach(yCheckValidExpr)
     end Apply
 
     given ApplyMethods: ApplyMethods with
@@ -2873,6 +2877,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           Extractors.showConstant(using QuotesImpl.this)(const)
 
     end Printer
+
+    private def yCheckValidExpr(term: Term): Unit =
+      if yCheck then
+        assert(!term.tpe.widenDealias.isInstanceOf[dotc.core.Types.MethodicType],
+          "Reference to method must be eta-expanded before it is used as an expression: " + term.show)
+
   end reflect
 
   def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Expr[T] =

tests/neg-macros/i11483/Macro_1.scala

@@ -0,0 +1,59 @@
+package x
+
+import scala.annotation._
+import scala.quoted._
+import scala.compiletime._
+
+
+trait CpsMonad[F[_]]:
+
+  def pure[T](x:T):F[T]
+
+  def impure[T](x:F[T]):T
+
+  def map[A,B](x:F[A])(f: A=>B):F[B]
+
+
+@compileTimeOnly("await should be inside async block")
+def await[F[_],T](f:F[T])(using am:CpsMonad[F]):T = ???
+
+inline given conversion[F[_],T](using CpsMonad[F]): Conversion[F[T],T] =
+           x => await(x)
+
+
+object X {
+
+ inline def process[F[_], T](inline t:T)(using m: CpsMonad[F]):F[T] =
+    ${ processImpl[F,T]('t, 'm) }
+
+
+ def processImpl[F[_]:Type, T:Type](t:Expr[T], m:Expr[CpsMonad[F]])(using Quotes):Expr[F[T]] =
+   import quotes.reflect._
+   val r = processTree[F,T](t.asTerm, m.asTerm)
+   r.asExprOf[F[T]]
+
+
+ def processTree[F[_]:Type, T:Type](using Quotes)(t: quotes.reflect.Term, m: quotes.reflect.Term):quotes.reflect.Term =
+   import quotes.reflect._
+   val r: Term = t match
+     case Inlined(_,List(),body) => processTree[F,T](body, m)
+     case Inlined(d,bindings,body) =>
+       Inlined(d,bindings,processTree[F,T](body, m))
+     case Block(stats,expr) => Block(stats,processTree(expr, m))
+     case Apply(Apply(TypeApply(Ident("await"),targs),List(body)),List(m)) => body
+     case Apply(f,List(arg)) =>
+          val nArg = processTree[F,String](arg, m)
+          Apply(Apply(TypeApply(Select.unique(m,"map"),
+                               List(Inferred(arg.tpe.widen),Inferred(t.tpe.widen))
+                      ),
+                      List(nArg)),
+                 List(f)
+          )
+     case Apply(f,List()) =>
+          Apply(TypeApply(Select.unique(m,"pure"),List(Inferred(t.tpe.widen))),List(t))
+     case Typed(x,tp) => Typed(processTree(x,m), Inferred(TypeRepr.of[F].appliedTo(tp.tpe)) )
+     case _ => throw new RuntimeException(s"tree not recoginized: $t")
+   r
+
+
+}

tests/neg-macros/i11483/Test_2.scala

@@ -0,0 +1,26 @@
+package x
+
+import scala.language.implicitConversions
+import scala.concurrent.Future
+
+given FutureAsyncMonad: CpsMonad[Future] with
+  def pure[T](t:T): Future[T] = ???
+  def impure[T](t:Future[T]): T = ???
+  def map[A,B](x:Future[A])(f: A=>B): Future[B] = ???
+
+
+object Api:
+
+  def doSomething():Future[String] =
+    Future.successful("doSomething")
+
+  def println(x:String):Unit =
+    Console.println(x)
+
+
+object Main:
+
+  def main(args: Array[String]): Unit =
+    X.process[Future,Unit]{ // error
+      Api.println(Api.doSomething())
+    }