Enhance constant-folding during inlining

Author: mbovel

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

@@ -16,7 +16,7 @@ import collection.mutable
 /** A utility class offering methods for rewriting inlined code */
 class InlineReducer(inliner: Inliner)(using Context):
   import tpd.*
-  import Inliner.{isElideableExpr, DefBuffer}
+  import Inliner.{isElideableExpr, DefBuffer, inlinedConstToLiteral}
   import inliner.{call, newSym, tryInlineArg, paramBindingDef}
 
   extension (tp: Type)
@@ -201,7 +201,7 @@ class InlineReducer(inliner: Inliner)(using Context):
         val copied = sym.copy(info = rhs.tpe.widenInlineScrutinee, coord = sym.coord,
           flags = sym.flags &~ Case).asTerm
         adjustErased(copied, rhs)
-        caseBindingMap += ((sym, ValDef(copied, constToLiteral(rhs)).withSpan(sym.span)))
+        caseBindingMap += ((sym, ValDef(copied, inlinedConstToLiteral(rhs)).withSpan(sym.span)))
 
       def newTypeBinding(sym: TypeSymbol, alias: Type): Unit = {
         val copied = sym.copy(info = TypeAlias(alias), coord = sym.coord).asType
@@ -321,7 +321,7 @@ class InlineReducer(inliner: Inliner)(using Context):
                 case (pat :: pats1, selector :: selectors1) =>
                   val elem = newSym(InlineBinderName.fresh(), Synthetic, selector.tpe.widenInlineScrutinee).asTerm
                   adjustErased(elem, selector)
-                  val rhs = constToLiteral(selector)
+                  val rhs = inlinedConstToLiteral(selector)
                   elem.defTree = rhs
                   caseBindingMap += ((NoSymbol, ValDef(elem, rhs).withSpan(elem.span)))
                   reducePattern(caseBindingMap, elem.termRef, pat) &&
@@ -337,7 +337,7 @@ class InlineReducer(inliner: Inliner)(using Context):
                   else paramCls.asClass.paramAccessors
                 val selectors =
                   for (accessor <- caseAccessors)
-                  yield constToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
+                  yield inlinedConstToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
                 caseAccessors.length == pats.length && reduceSubPatterns(pats, selectors)
               }
               else false

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

@@ -183,6 +183,25 @@ object Inliner:
 
   end OpaqueProxy
 
+  /** A more powerful version of `constToLiteral` that also recurses through elidable (see [[isElideableExpr]]) [[Block]], [[Inlined]], and [[Typed]] nodes.
+   */
+  def inlinedConstToLiteral(rootTree: Tree)(using Context): Tree =
+    def rec(tree: Tree): Tree =
+      inline def recChild(subTree: Tree): Tree =
+        val res = rec(subTree)
+        if res eq subTree then tree else res
+
+      tree match
+        case Typed(expr, _) => recChild(expr)
+        case Inlined(_, _, expr) => recChild(expr)
+        case Block(_, expr) => recChild(expr)
+        case _ => constToLiteral(tree)
+
+    if isElideableExpr(rootTree) then
+      rec(rootTree)
+    else
+      constToLiteral(rootTree)
+
   private[inlines] def newSym(name: Name, flags: FlagSet, info: Type, span: Span)(using Context): Symbol =
     newSymbol(ctx.owner, name, flags, info, coord = span)
 end Inliner
@@ -897,7 +916,7 @@ class Inliner(val call: tpd.Tree)(using Context):
         //if the projection leads to a typed tree then we stop reduction
         resNoReduce
       else
-        val res = constToLiteral(reducedProjection)
+        val res = inlinedConstToLiteral(reducedProjection)
         if resNoReduce ne res then
           typed(res, pt) // redo typecheck if reduction changed something
         else if res.symbol.isInlineMethod then
@@ -928,19 +947,19 @@ class Inliner(val call: tpd.Tree)(using Context):
     override def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree =
       val vdef1 =
         if sym.is(Inline) then
-          val rhs = typed(vdef.rhs)
+          val rhs = inlinedConstToLiteral(typed(vdef.rhs))
           sym.info = rhs.tpe
           untpd.cpy.ValDef(vdef)(vdef.name, untpd.TypeTree(rhs.tpe), untpd.TypedSplice(rhs))
         else vdef
       super.typedValDef(vdef1, sym)
 
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
-      specializeEq(inlineIfNeeded(constToLiteral(BetaReduce(super.typedApply(tree, pt))), pt, locked))
+      specializeEq(inlineIfNeeded(inlinedConstToLiteral(BetaReduce(super.typedApply(tree, pt))), pt, locked))
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
-      val tree1 = inlineIfNeeded(constToLiteral(BetaReduce(super.typedTypeApply(tree, pt))), pt, locked)
+      val tree1 = inlineIfNeeded(inlinedConstToLiteral(BetaReduce(super.typedTypeApply(tree, pt))), pt, locked)
       if tree1.symbol == defn.QuotedTypeModule_of then
         ctx.compilationUnit.needsStaging = true
       tree1
@@ -1021,8 +1040,8 @@ class Inliner(val call: tpd.Tree)(using Context):
                   case _ => rhs0
                 }
                 val rhs2 = rhs1 match {
-                  case Typed(expr, tpt) if rhs1.span.isSynthetic => constToLiteral(expr)
-                  case _ => constToLiteral(rhs1)
+                  case Typed(expr, tpt) if rhs1.span.isSynthetic => inlinedConstToLiteral(expr)
+                  case _ => inlinedConstToLiteral(rhs1)
                 }
                 val (usedBindings, rhs3) = dropUnusedDefs(caseBindings, rhs2)
                 val rhs = seq(usedBindings, rhs3)
@@ -1056,7 +1075,7 @@ class Inliner(val call: tpd.Tree)(using Context):
       val meth = tree.symbol
       if meth.isAllOf(DeferredInline) then
         errorTree(tree, em"Deferred inline ${meth.showLocated} cannot be invoked")
-      else if Inlines.needsInlining(tree) then Inlines.inlineCall(simplify(tree, pt, locked))
+      else if Inlines.needsInlining(tree) then inlinedConstToLiteral(Inlines.inlineCall(simplify(tree, pt, locked)))
       else tree
 
     override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =

tests/neg/i18123b.check

@@ -0,0 +1,9 @@
+-- [E007] Type Mismatch Error: tests/neg/i18123b.scala:8:8 -------------------------------------------------------------
+8 |def z = y.rep().toUpperCase // error
+  |        ^^^^^^^
+  |        Found:    (??? : => Nothing)
+  |        Required: ?{ toUpperCase: ? }
+  |        Note that implicit conversions were not tried because the result of an implicit conversion
+  |        must be more specific than ?{ toUpperCase: <?> }
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg/i18123b.scala

@@ -0,0 +1,8 @@
+// Minimized version of `tests/pos/i18123.scala` to test #24425.
+
+extension (x: String)
+  transparent inline def rep(min: Int = 0): String = ???
+
+def y: String = ???
+
+def z = y.rep().toUpperCase // error

tests/pos/i24412.scala

@@ -0,0 +1,13 @@
+object test {
+  import scala.compiletime.erasedValue
+
+  inline def contains[T <: Tuple, E]: Boolean = inline erasedValue[T] match {
+    case _: EmptyTuple => false
+    case _: (_ *: tail) => contains[tail, E]
+  }
+  inline def check[T <: Tuple]: Unit = {
+    inline if contains[T, Long] && false then ???
+  }
+
+  check[(String, Double)]
+}

tests/run/i24420-inline-local-ref.scala

@@ -0,0 +1,12 @@
+inline def f(): Long =
+  1L
+
+inline def g(): Long =
+  inline val x = f()
+  x
+
+inline def h(): Long =
+  inline if g() > 0L then 1L else 0L
+
+@main def Test: Unit =
+  assert(h() == 1L)

tests/run/i24420-inline-val.scala

@@ -0,0 +1,25 @@
+inline def f1(): Long =
+  1L
+
+inline def f2(): Long =
+  inline val x = f1() + 1L
+  x
+
+inline def f3(): Long =
+  inline val x = f1()
+  x
+
+inline def g1(): Boolean =
+  true
+
+inline def g2(): Long =
+  inline if g1() then 1L else 2L
+
+inline def g3(): Long =
+  inline if f1() > 0L then 1L else 2L
+
+@main def Test: Unit =
+  assert(f2() == 2L)
+  assert(f3() == 1L)
+  assert(g2() == 1L)
+  assert(g3() == 1L)

tests/run/i24420-transparent-inline-local-ref.scala

@@ -0,0 +1,12 @@
+transparent inline def f(): Long =
+  1L
+
+transparent inline def g(): Long =
+  inline val x = f()
+  x
+
+transparent inline def h(): Long =
+  inline if g() > 0L then 1L else 0L
+
+@main def Test: Unit =
+  assert(h() == 1L)