Refactor inlining condition logic

Author: nicolasstucki

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

@@ -87,7 +87,7 @@ class Inlining extends MacroTransform {
           else super.transform(tree)
         case _: Typed | _: Block =>
           super.transform(tree)
-        case _ if Inliner.isInlineable(tree) && !tree.tpe.widen.isInstanceOf[MethodOrPoly] && StagingContext.level == 0 =>
+        case _ if Inliner.needsInlining(tree) =>
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inliner.inlineCall(tree1)

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

@@ -52,16 +52,29 @@ object Inliner {
   def inInlineMethod(using Context): Boolean =
     ctx.owner.ownersIterator.exists(_.isInlineMethod)
 
-  /** Should call to method `meth` be inlined in this context? */
+  /** Can a call to method `meth` be inlined? */
   def isInlineable(meth: Symbol)(using Context): Boolean =
     meth.is(Inline) && meth.hasAnnotation(defn.BodyAnnot) && !inInlineMethod
 
   /** Should call be inlined in this context? */
-  def isInlineable(tree: Tree)(using Context): Boolean = tree match {
-    case Block(_, expr) => isInlineable(expr)
-    case _ => isInlineable(tree.symbol) && !tree.tpe.isInstanceOf[MethodOrPoly]
+  def needsInlining(tree: Tree)(using Context): Boolean = tree match {
+    case Block(_, expr) => needsInlining(expr)
+    case _ =>
+      isInlineable(tree.symbol)
+      && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly]
+      && StagingContext.level == 0
+      && (
+        ctx.phase == Phases.inliningPhase
+        || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree))
+      )
+      && !ctx.typer.hasInliningErrors
   }
 
+  private def needsTransparentInlining(tree: Tree)(using Context): Boolean =
+    tree.symbol.is(Transparent)
+    || ctx.mode.is(Mode.ForceInline)
+    || ctx.settings.YforceInlineWhileTyping.value
+
   /** Try to inline a call to an inline method. Fail with error if the maximal
    *  inline depth is exceeded.
    *
@@ -283,14 +296,15 @@ object Inliner {
       assert(tree.symbol == defn.CompiletimeTesting_typeChecks || tree.symbol == defn.CompiletimeTesting_typeCheckErrors)
       def stripTyped(t: Tree): Tree = t match {
         case Typed(t2, _) => stripTyped(t2)
+        case Block(Nil, t2) => stripTyped(t2)
         case Inlined(_, Nil, t2) => stripTyped(t2)
         case _ => t
       }
 
       val Apply(_, codeArg :: Nil) = tree
       val codeArg1 = stripTyped(codeArg.underlying)
       val underlyingCodeArg =
-        if Inliner.isInlineable(codeArg1) then stripTyped(Inliner.inlineCall(codeArg1))
+        if Inliner.isInlineable(codeArg1.symbol) then stripTyped(Inliner.inlineCall(codeArg1))
         else codeArg1
 
       ConstFold(underlyingCodeArg).tpe.widenTermRefExpr match {
@@ -1240,9 +1254,14 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       super.ensureAccessible(tpe, superAccess, pos)
     }
 
+    override def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
+      val tree1 = super.typed(tree, pt)
+      if Inliner.needsInlining(tree1)
+      then Inliner.inlineCall(tree1)
+      else tree1
+
     override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
-      val tree1 = tryInlineArg(tree.asInstanceOf[tpd.Tree]) `orElse` super.typedIdent(tree, pt)
-      inlineIfIsNestedInlineCall(tree1)
+      tryInlineArg(tree.asInstanceOf[tpd.Tree]) `orElse` super.typedIdent(tree, pt)
 
     override def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
       assert(tree.hasType, tree)
@@ -1254,7 +1273,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       else
         val res = resMaybeReduced
         ensureAccessible(res.tpe, tree.qualifier.isInstanceOf[untpd.Super], tree.srcPos)
-        inlineIfIsNestedInlineCall(res)
+        res
     }
 
     override def typedIf(tree: untpd.If, pt: Type)(using Context): Tree =
@@ -1287,18 +1306,18 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       val res = constToLiteral(betaReduce(super.typedApply(tree, pt))) match {
         case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
                         && level == 0
-                        && !suppressInline =>
+                        && !hasInliningErrors =>
           val expanded = expandMacro(res.args.head, tree.span)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
         case res =>
-          inlineIfIsNestedInlineCall(res)
+          res
       }
       if res.symbol == defn.QuotedRuntime_exprQuote then
         ctx.compilationUnit.needsQuotePickling = true
       res
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
-      inlineIfIsNestedInlineCall(constToLiteral(betaReduce(super.typedTypeApply(tree, pt))))
+      constToLiteral(betaReduce(super.typedTypeApply(tree, pt)))
 
     override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
       val tree1 =
@@ -1354,19 +1373,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
 
     override def newLikeThis: Typer = new InlineTyper(initialErrorCount)
 
-    /** Suppress further inlining if this inline typer has already issued errors */
-    override def suppressInline(using Context) =
-      ctx.reporter.errorCount > initialErrorCount || super.suppressInline
-
-    private def inlineIfIsNestedInlineCall(tree: Tree)(using Context): Tree =
-      if
-        !suppressInline &&
-        !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly] &&
-        Inliner.isInlineable(tree) &&
-        StagingContext.level == 0 &&
-        (ctx.isAfterTyper || tree.symbol.is(Transparent) || ctx.mode.is(Mode.ForceInline) || ctx.settings.YforceInlineWhileTyping.value)
-      then Inliner.inlineCall(tree)
-      else tree
+    /** True if this inline typer has already issued errors */
+    override def hasInliningErrors(using Context) = ctx.reporter.errorCount > initialErrorCount
+
   }
 
   /** Drop any side-effect-free bindings that are unused in expansion or other reachable bindings.

compiler/src/dotty/tools/dotc/typer/ReTyper.scala

@@ -118,7 +118,7 @@ class ReTyper extends Typer with ReChecking {
     try super.typedUnadapted(tree, pt, locked)
     catch {
       case NonFatal(ex) =>
-        if ctx.isAfterTyper && ctx.phase != Phases.inliningPhase then
+        if ctx.phase != Phases.typerPhase && ctx.phase != Phases.inliningPhase then
           println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
         throw ex
     }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -865,9 +865,9 @@ class Typer extends Namer
      */
     val arg1 = pt match {
       case AppliedType(a, typ :: Nil) if ctx.isJava && a.isRef(defn.ArrayClass) =>
-        tryAlternatively { typed(tree.arg, pt) } { 
+        tryAlternatively { typed(tree.arg, pt) } {
             val elemTp = untpd.TypedSplice(TypeTree(typ))
-            typed(untpd.JavaSeqLiteral(tree.arg :: Nil, elemTp), pt) 
+            typed(untpd.JavaSeqLiteral(tree.arg :: Nil, elemTp), pt)
         }
       case _ => typed(tree.arg, pt)
     }
@@ -3406,11 +3406,7 @@ class Typer extends Namer
         val meth = methPart(tree).symbol
         if meth.isAllOf(DeferredInline) && !Inliner.inInlineMethod then
           errorTree(tree, i"Deferred inline ${meth.showLocated} cannot be invoked")
-        else if
-          Inliner.isInlineable(tree) &&
-          !suppressInline &&
-          StagingContext.level == 0 &&
-          (tree.symbol.is(Transparent) || ctx.settings.YforceInlineWhileTyping.value)
+        else if Inliner.needsInlining(tree)
         then
           tree.tpe <:< wildApprox(pt)
           val errorCount = ctx.reporter.errorCount
@@ -3734,8 +3730,8 @@ class Typer extends Namer
     }
   }
 
-  // Overridden in InlineTyper
-  def suppressInline(using Context): Boolean = ctx.isAfterTyper && ctx.phase != Phases.inliningPhase
+  /** True if this inline typer has already issued errors */
+  def hasInliningErrors(using Context): Boolean = false
 
   /** Does the "contextuality" of the method type `methType` match the one of the prototype `pt`?
    *  This is the case if

tests/pos-custom-args/erased/i7878.scala

@@ -2,7 +2,7 @@ object Boom {
   import scala.compiletime._
   trait Fail[A <: Int, B <: Int]
 
-  erased inline given fail[X <: Int, Y <: Int]: Fail[X, Y] = {
+  erased transparent inline given fail[X <: Int, Y <: Int]: Fail[X, Y] = {
      scala.compiletime.summonFrom {
        case t: Fail[X, y] if constValue[y] < constValue[Y] => ???
     }