Fix #8290: Make Expr.betaReduce give up when it sees a non-function typed closure

Adapted from 30b35f1

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -2051,23 +2051,33 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     }}
     val argVals = argVals0.reverse
     val argRefs = argRefs0.reverse
-    val reducedBody = lambdaExtractor(fn) match {
+    val reducedBody = lambdaExtractor(fn, argRefs.map(_.tpe)) match {
       case Some(body) => body(argRefs)
       case None => fn.select(nme.apply).appliedToArgs(argRefs)
     }
     seq(argVals, reducedBody).withSpan(fn.span)
   }
 
-  def lambdaExtractor(fn: Term)(using ctx: Context): Option[List[Term] => Term] = {
+  def lambdaExtractor(fn: Term, paramTypes: List[Type])(using ctx: Context): Option[List[Term] => Term] = {
     def rec(fn: Term, transformBody: Term => Term): Option[List[Term] => Term] = {
       fn match {
         case Inlined(call, bindings, expansion) =>
           // this case must go before closureDef to avoid dropping the inline node
           rec(expansion, cpy.Inlined(fn)(call, bindings, _))
         case Typed(expr, tpt) =>
-          val resTpe = tpt.tpe.dropDependentRefinement.argInfos.last
-          rec(expr, Typed(_, TypeTree(resTpe).withSpan(tpt.span)))
-        case closureDef(ddef) =>
+          val tpe = tpt.tpe.dropDependentRefinement
+          // we checked that this is a plain Function closure, so there will be an apply method with a MethodType
+          // and the expected signature based on param types
+          val expectedSig = Signature.NotAMethod.prependTermParams(paramTypes, false)
+          val method = tpt.tpe.member(nme.apply).atSignature(expectedSig)
+          if method.symbol.is(Deferred) then
+            val methodType = method.info.asInstanceOf[MethodType]
+            // result might contain paramrefs, so we substitute them with arg termrefs
+            val resultTypeWithSubst = methodType.resultType.substParams(methodType, paramTypes)
+            rec(expr, Typed(_, TypeTree(resultTypeWithSubst).withSpan(tpt.span)))
+          else
+            None
+        case cl @ closureDef(ddef) =>
           def replace(body: Term, argRefs: List[Term]): Term = {
             val paramSyms = ddef.vparamss.head.map(param => param.symbol)
             val paramToVals = paramSyms.zip(argRefs).toMap

library/src/scala/quoted/matching/Lambda.scala

@@ -16,9 +16,11 @@ object Lambda {
    *       body('{3}) // returns '{ println(3) }
    *   ```
    */
-  def unapply[F, Args <: Tuple, Res, G](expr: Expr[F])(using qctx: QuoteContext, tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, Expr] => Expr[Res]]): Option[/*QuoteContext ?=>*/ G] = {
+  def unapply[F, Args <: Tuple, Res, G](expr: Expr[F])(using qctx: QuoteContext, tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, Expr] => Expr[Res]], functionType: Type[F]): Option[/*QuoteContext ?=>*/ G] = {
     import qctx.tasty.{_, given _ }
-    qctx.tasty.internal.lambdaExtractor(expr.unseal).map { fn =>
+    val argTypes = functionType.unseal.tpe match
+      case AppliedType(_, functionArguments) => functionArguments.init.asInstanceOf[List[Type]]
+    qctx.tasty.internal.lambdaExtractor(expr.unseal, argTypes).map { fn =>
       def f(args: Tuple.Map[Args, Expr]): Expr[Res] =
         fn(args.toArray.map(_.asInstanceOf[Expr[Any]].unseal).toList).seal.asInstanceOf[Expr[Res]]
       tg.untupled(f)

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1543,6 +1543,6 @@ trait CompilerInterface {
    */
   def betaReduce(f: Term, args: List[Term])(using ctx: Context): Term
 
-  def lambdaExtractor(term: Term)(using ctx: Context): Option[List[Term] => Term]
+  def lambdaExtractor(term: Term, paramTypes: List[Type])(using ctx: Context): Option[List[Term] => Term]
 
 }

tests/run-macros/beta-reduce-inline-result.check

@@ -3,3 +3,6 @@ run-time: 4
 compile-time: 1
 run-time: 1
 run-time: 5
+run-time: 7
+run-time: -1
+run-time: 9

tests/run-macros/beta-reduce-inline-result/Test_2.scala

@@ -1,7 +1,7 @@
 import scala.compiletime._
 
 object Test {
-  
+
   inline def dummy1: Int => Int =
     (i: Int) => i + 1
 
@@ -14,6 +14,36 @@ object Test {
   inline def dummy4: Int => Int =
     ???
 
+  object I extends (Int => Int) {
+    def apply(i: Int): i.type = i
+  }
+
+  abstract class II extends (Int => Int) {
+    val apply = 123
+  }
+
+  inline def dummy5: II =
+    (i: Int) => i + 1
+
+  abstract class III extends (Int => Int) {
+    def impl(i: Int): Int
+    def apply(i: Int): Int = -1
+  }
+
+  inline def dummy6: III =
+    (i: Int) => i + 1
+
+  abstract class IV extends (Int => Int) {
+    def apply(s: String): String
+  }
+
+  abstract class V extends IV {
+    def apply(s: String): String = "gotcha"
+  }
+
+  inline def dummy7: IV =
+    { (i: Int) => i + 1 } : V
+
   def main(argv : Array[String]) : Unit = {
     println(code"compile-time: ${Macros.betaReduce(dummy1)(3)}")
     println(s"run-time: ${Macros.betaReduce(dummy1)(3)}")
@@ -27,7 +57,21 @@ object Test {
     def throwsNotImplemented2 = Macros.betaReduce(dummy4)(6)
 
     // make sure paramref types work when inlining is not possible
-    println(s"run-time: ${Macros.betaReduce(Predef.identity)(5)}")
+    println(s"run-time: ${Macros.betaReduce(I)(5)}")
+
+    // -- cases below are non-function types, which are currently not inlined for simplicity but may be in the future
+    // (also, this tests that we return something valid when we see a closure that we can't inline)
+
+    // A non-function type with an apply value that can be confused with the apply method.
+    println(s"run-time: ${Macros.betaReduce(dummy5)(6)}")
+
+    // should print -1 (without inlining), because the apparent apply method actually
+    // has nothing to do with the function literal
+    println(s"run-time: ${Macros.betaReduce(dummy6)(7)}")
+
+    // the literal does contain the implementation of the apply method, but there are two abstract apply methods
+    // in the outermost abstract type
+    println(s"run-time: ${Macros.betaReduce(dummy7)(8)}")
   }
 }