Merge pull request #9469 from dotty-staging/rework-quoted-expr-beta-reduce

Redefine quoted.Expr.betaReduce

Author: nicolasstucki

community-build/community-projects/dotty-cps-async

@@ -2045,21 +2045,18 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case _ => None
   }
 
-  def betaReduce(fn: Term, args: List[Term])(using Context): Term = {
-    val (argVals0, argRefs0) = args.foldLeft((List.empty[ValDef], List.empty[Tree])) { case ((acc1, acc2), arg) => arg.tpe match {
-      case tpe: SingletonType if isIdempotentExpr(arg) => (acc1, arg :: acc2)
+  def betaReduce(tree: Term)(using Context): Option[Term] =
+    tree match
+      case app @ Apply(Select(fn, nme.apply), args) if defn.isFunctionType(fn.tpe) =>
+        val app1 = transform.BetaReduce(app, fn, args)
+        if app1 eq app then None
+        else Some(app1.withSpan(tree.span))
+      case Block(Nil, expr) =>
+        for e <- betaReduce(expr) yield cpy.Block(tree)(Nil, e)
+      case Inlined(_, Nil, expr) =>
+        betaReduce(expr)
       case _ =>
-        val argVal = SyntheticValDef(NameKinds.UniqueName.fresh("x".toTermName), arg).withSpan(arg.span)
-        (argVal :: acc1, ref(argVal.symbol) :: acc2)
-    }}
-    val argVals = argVals0.reverse
-    val argRefs = argRefs0.reverse
-    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)
-  }
+        None
 
   def lambdaExtractor(fn: Term, paramTypes: List[Type])(using Context): Option[List[Term] => Term] = {
     def rec(fn: Term, transformBody: Term => Term): Option[List[Term] => Term] = {

community-build/community-projects/utest

@@ -37,22 +37,26 @@ class BetaReduce extends MiniPhase:
 
   override def transformApply(app: Apply)(using Context): Tree = app.fun match
     case Select(fn, nme.apply) if defn.isFunctionType(fn.tpe) =>
-      val app1 = betaReduce(app, fn, app.args)
+      val app1 = BetaReduce(app, fn, app.args)
       if app1 ne app then report.log(i"beta reduce $app -> $app1")
       app1
     case _ =>
       app
 
-  private def betaReduce(tree: Apply, fn: Tree, args: List[Tree])(using Context): Tree =
-    fn match
-      case Typed(expr, _) => betaReduce(tree, expr, args)
-      case Block(Nil, expr) => betaReduce(tree, expr, args)
-      case Block((anonFun: DefDef) :: Nil, closure: Closure) => BetaReduce(anonFun, args)
-      case _ => tree
 
 object BetaReduce:
   import ast.tpd._
 
+  /** Beta-reduces a call to `fn` with arguments `argSyms` or returns `tree` */
+  def apply(tree: Apply, fn: Tree, args: List[Tree])(using Context): Tree =
+    fn match
+      case Typed(expr, _) => BetaReduce(tree, expr, args)
+      case Block(Nil, expr) => BetaReduce(tree, expr, args)
+      case Inlined(_, Nil, expr) => BetaReduce(tree, expr, args)
+      case Block((anonFun: DefDef) :: Nil, closure: Closure) => BetaReduce(anonFun, args)
+      case _ => tree
+  end apply
+
   /** Beta-reduces a call to `ddef` with arguments `argSyms` */
   def apply(ddef: DefDef, args: List[Tree])(using Context) =
     val bindings = List.newBuilder[ValDef]
@@ -65,7 +69,8 @@ object BetaReduce:
             ref.symbol
           case _ =>
             val flags = Synthetic | (param.symbol.flags & Erased)
-            val binding = ValDef(newSymbol(ctx.owner, param.name, flags, arg.tpe.widen, coord = arg.span), arg)
+            val tpe = if arg.tpe.dealias.isInstanceOf[ConstantType] then arg.tpe.dealias else arg.tpe.widen
+            val binding = ValDef(newSymbol(ctx.owner, param.name, flags, tpe, coord = arg.span), arg).withSpan(arg.span)
             bindings += binding
             binding.symbol
 
@@ -76,5 +81,13 @@ object BetaReduce:
       substTo = argSyms
     ).transform(ddef.rhs)
 
-    seq(bindings.result(), expansion)
+    val expansion1 = new TreeMap {
+      override def transform(tree: Tree)(using Context) = tree.tpe.widenTermRefExpr match
+        case ConstantType(const) if isPureExpr(tree) => cpy.Literal(tree)(const)
+        case _ => super.transform(tree)
+    }.transform(expansion)
+    val bindings1 =
+      bindings.result().filterNot(vdef => vdef.tpt.tpe.isInstanceOf[ConstantType] && isPureExpr(vdef.rhs))
+
+    seq(bindings1, expansion1)
   end apply

community-build/community-projects/xml-interpolator

@@ -399,22 +399,15 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val instructions = instructionsFromMethod(fun)
       val expected =
         List(
-          // Head tested separatly
           VarOp(ALOAD, 0),
           Invoke(INVOKEVIRTUAL, "Test", "given_Int", "()I", false),
-          Invoke(INVOKESTATIC, "scala/runtime/BoxesRunTime", "boxToInteger", "(I)Ljava/lang/Integer;", false),
-          Invoke(INVOKEINTERFACE, "dotty/runtime/function/JFunction1$mcZI$sp", "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", true),
-          Invoke(INVOKESTATIC, "scala/runtime/BoxesRunTime", "unboxToBoolean", "(Ljava/lang/Object;)Z", false),
+          VarOp(ISTORE, 1),
+          Op(ICONST_1),
           Op(IRETURN)
         )
 
-      instructions.head match {
-        case InvokeDynamic(INVOKEDYNAMIC, "apply$mcZI$sp", "()Ldotty/runtime/function/JFunction1$mcZI$sp;", _, _) =>
-        case _ => assert(false, "`g` was not properly inlined in `test`\n")
-      }
-
-      assert(instructions.tail == expected,
-        "`fg was not properly inlined in `test`\n" + diffInstructions(instructions.tail, expected))
+      assert(instructions == expected,
+        "`fg was not properly inlined in `test`\n" + diffInstructions(instructions, expected))
 
     }
   }
@@ -505,4 +498,30 @@ class InlineBytecodeTests extends DottyBytecodeTest {
     }
   }
 
+
+  @Test def i9466 = {
+    val source = """class Test:
+                   |  inline def i(inline f: Int => Boolean): String =
+                   |   if f(34) then "a"
+                   |   else "b"
+                   |  def test = i(f = _ == 34)
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Test.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn)
+
+      val fun = getMethod(clsNode, "test")
+      val instructions = instructionsFromMethod(fun)
+      val expected =
+        List(
+          Ldc(LDC, "a"),
+          Op(ARETURN)
+        )
+
+      assert(instructions == expected,
+        "`i was not properly inlined in `test`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
 }

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

@@ -61,30 +61,15 @@ abstract class Expr[+T] private[scala] {
 
 object Expr {
 
-  /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
-  type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, [X] =>> QuoteContext ?=> Expr[X]]
-
-  /** `Expr.betaReduce(f)(x1, ..., xn)` is functionally the same as `'{($f)($x1, ..., $xn)}`, however it optimizes this call
-   *   by returning the result of beta-reducing `f(x1, ..., xn)` if `f` is a known lambda expression.
-   *
-   *  `Expr.betaReduce` distributes applications of `Expr` over function arrows
-   *   ```scala
-   *   Expr.betaReduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
-   *   ```
-   */
-  def betaReduce[F, Args <: Tuple, R, G](f: Expr[F])(using tf: TupledFunction[F, Args => R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G =
-    tg.untupled(args => qctx.tasty.internal.betaReduce(f.unseal, args.toArray.toList.map(_.asInstanceOf[QuoteContext => Expr[Any]](qctx).unseal)).seal.asInstanceOf[Expr[R]])
-
-  /** `Expr.betaReduceGiven(f)(x1, ..., xn)` is functionally the same as `'{($f)(using $x1, ..., $xn)}`, however it optimizes this call
-   *   by returning the result of beta-reducing `f(using x1, ..., xn)` if `f` is a known lambda expression.
-   *
-   *  `Expr.betaReduceGiven` distributes applications of `Expr` over function arrows
-   *   ```scala
-   *   Expr.betaReduceGiven(_): Expr[(T1, ..., Tn) ?=> R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
-   *   ```
+  /** `e.betaReduce` returns an expression that is functionally equivalent to `e`,
+   *   however if `e` is of the form `((y1, ..., yn) => e2)(x1, ..., xn)`
+   *   then it optimizes this the top most call by returning the result of beta-reducing the application.
+   *   Otherwise returns `expr`.
    */
-  def betaReduceGiven[F, Args <: Tuple, R, G](f: Expr[F])(using tf: TupledFunction[F, Args ?=> R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G =
-    tg.untupled(args => qctx.tasty.internal.betaReduce(f.unseal, args.toArray.toList.map(_.asInstanceOf[QuoteContext => Expr[Any]](qctx).unseal)).seal.asInstanceOf[Expr[R]])
+  def betaReduce[T](expr: Expr[T])(using qctx: QuoteContext): Expr[T] =
+    qctx.tasty.internal.betaReduce(expr.unseal) match
+      case Some(expr1) => expr1.seal.asInstanceOf[Expr[T]]
+      case _ => expr
 
   /** Returns a null expresssion equivalent to `'{null}` */
   def nullExpr: QuoteContext ?=> Expr[Null] = qctx ?=> {

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

@@ -22,7 +22,7 @@ object UnsafeExpr {
   def underlyingArgument[T](expr: Expr[T])(using qctx: QuoteContext): Expr[T] =
     expr.unseal.underlyingArgument.seal.asInstanceOf[Expr[T]]
 
-  // TODO generalize for any function arity (see Expr.betaReduce)
+  // TODO generalize for any function arity
   /** Allows inspection or transformation of the body of the expression of function.
    *  This body may have references to the arguments of the function which should be closed
    *  over if the expression will be spliced.

compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala

@@ -1610,10 +1610,8 @@ trait CompilerInterface {
    */
   def searchImplicit(tpe: Type)(using ctx: Context): ImplicitSearchResult
 
-  /** Inline fn if it is an explicit closure possibly nested inside the expression of a block.
-   *  Otherwise apply the arguments to the closure.
-   */
-  def betaReduce(f: Term, args: List[Term])(using ctx: Context): Term
+  /** Returns Some with a beta-reduced application or None */
+  def betaReduce(tree: Term)(using Context): Option[Term]
 
   def lambdaExtractor(term: Term, paramTypes: List[Type])(using ctx: Context): Option[List[Term] => Term]
 

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -4,7 +4,7 @@ object Macros {
   inline def betaReduce[Arg,Result](inline fn: Arg=>Result)(inline arg: Arg): Result =
     ${ betaReduceImpl('{ fn })('{ arg }) }
 
-  def betaReduceImpl[Arg,Result](fn: Expr[Arg=>Result])(arg: Expr[Arg])(using qctx: QuoteContext): Expr[Result] =
-    Expr.betaReduce(fn)(arg)
+  def betaReduceImpl[Arg: Type, Result: Type](fn: Expr[Arg=>Result])(arg: Expr[Arg])(using qctx: QuoteContext): Expr[Result] =
+    Expr.betaReduce('{$fn($arg)})
 }