Only run inlining phase when needed

Author: nicolasstucki

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -38,6 +38,11 @@ class CompilationUnit protected (val source: SourceFile) {
    */
   val freshNames: FreshNameCreator = new FreshNameCreator.Default
 
+  /** Will be set to `true` if there are inline call that must be inlined after typer.
+   *  The information is used in phase `Inlining` in order to avoid traversing trees that need no transformations.
+   */
+  var needsInlining: Boolean = false
+
   /** Will be set to `true` if contains `Quote`.
    *  The information is used in phase `Staging` in order to avoid traversing trees that need no transformations.
    */
@@ -100,6 +105,7 @@ object CompilationUnit {
       force.traverse(unit1.tpdTree)
       unit1.needsStaging = force.containsQuote
       unit1.needsQuotePickling = force.containsQuote
+      unit1.needsInlining = force.containsInline
     }
     unit1
   }
@@ -126,9 +132,12 @@ object CompilationUnit {
   /** Force the tree to be loaded */
   private class Force extends TreeTraverser {
     var containsQuote = false
+    var containsInline = false
     def traverse(tree: Tree)(using Context): Unit = {
       if (tree.symbol.isQuote)
         containsQuote = true
+      if tree.symbol.is(Flags.Inline) then
+        containsInline = true
       traverseChildren(tree)
     }
   }

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

@@ -40,8 +40,9 @@ class Inlining extends MacroTransform {
   override def allowsImplicitSearch: Boolean = true
 
   override def run(using Context): Unit =
-    try super.run
-    catch case _: CompilationUnit.SuspendException => ()
+    if ctx.compilationUnit.needsInlining then
+      try super.run
+      catch case _: CompilationUnit.SuspendException => ()
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
     val newUnits = super.runOn(units).filterNot(_.suspended)

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

@@ -258,12 +258,16 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     override def transform(tree: Tree)(using Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
           checkNoConstructorProxy(tree)
           tree.tpe match {
             case tpe: ThisType => This(tpe.cls).withSpan(tree.span)
             case _ => tree
           }
         case tree @ Select(qual, name) =>
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.srcPos)
             withMode(Mode.Type)(super.transform(tree))
@@ -272,6 +276,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             checkNoConstructorProxy(tree)
             transformSelect(tree, Nil)
         case tree: Apply =>
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
           val methType = tree.fun.tpe.widen
           val app =
             if (methType.isErasedMethod)
@@ -303,6 +309,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           if tree.symbol.isQuote then
             ctx.compilationUnit.needsStaging = true
             ctx.compilationUnit.needsQuotePickling = true
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           args.foreach(checkInferredWellFormed)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)