Drop PruneErasedDefs

The motivation for the phase was always unclear to me. No tests broke after the change.

Piggybacked on the phase was the unrelated "anonymous class in inline method" warning.
I moved it in changed form to FirstTransform. It is more efficient now since it does
not need an auxiliary tree traversal.

Author: odersky

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

@@ -92,8 +92,7 @@ class Compiler {
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
          new StringInterpolatorOpt,  // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats
          new DropBreaks) ::          // Optimize local Break throws by rewriting them
-    List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
-         new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
+    List(new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
          new InlinePatterns,         // Remove placeholders of inlined patterns
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays

compiler/src/dotty/tools/dotc/cc/ccConfig.scala

@@ -56,6 +56,6 @@ object ccConfig:
 
   /** Not used currently. Handy for trying out new features */
   def newScheme(using ctx: Context): Boolean =
-    ctx.settings.XdropComments.value
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
 
 end ccConfig

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

@@ -20,6 +20,8 @@ import StdNames.*
 import config.Feature
 import inlines.Inlines.inInlineMethod
 import util.Property
+import inlines.Inlines
+import reporting.InlinedAnonClassWarning
 
 object FirstTransform {
   val name: String = "firstTransform"
@@ -207,6 +209,11 @@ class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
       case _ => tree
     }
 
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree =
+    if tree.symbol.isAnonymousClass && Inlines.inInlineMethod then
+      report.warning(InlinedAnonClassWarning(), tree.symbol.sourcePos)
+    tree
+
   /** Perform one of the following simplification if applicable:
    *
    *      true  && y   ==>  y

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

@@ -335,15 +335,6 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         }
     }
 
-    private object dropInlines extends TreeMap {
-      override def transform(tree: Tree)(using Context): Tree = tree match {
-        case tree @ Inlined(call, _, expansion) =>
-          val newExpansion = PruneErasedDefs.trivialErasedTree(tree)
-          cpy.Inlined(tree)(call, Nil, newExpansion)
-        case _ => super.transform(tree)
-      }
-    }
-
     def checkUsableAsValue(tree: Tree)(using Context): Tree =
       def unusable(msg: Symbol => Message) =
         errorTree(tree, msg(tree.symbol))
@@ -414,26 +405,13 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
             checkUsableAsValue(tree) match
               case tree1: Select => transformSelect(tree1, Nil)
               case tree1 => tree1
-        case tree: Apply =>
-          val methType = tree.fun.tpe.widen.asInstanceOf[MethodType]
-          val app =
-            if (methType.hasErasedParams)
-              tpd.cpy.Apply(tree)(
-                tree.fun,
-                tree.args.zip(methType.erasedParams).map((arg, isErased) =>
-                  if !isErased then arg
-                  else
-                    if methType.isResultDependent then
-                      Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
-                    if (methType.isImplicitMethod && arg.span.isSynthetic)
-                      arg match
-                        case _: RefTree | _: Apply | _: TypeApply if arg.symbol.is(Erased) =>
-                          dropInlines.transform(arg)
-                        case _ =>
-                          PruneErasedDefs.trivialErasedTree(arg)
-                    else dropInlines.transform(arg)))
-            else
-              tree
+        case app: Apply =>
+          val methType = app.fun.tpe.widen.asInstanceOf[MethodType]
+          if (methType.hasErasedParams)
+            for (arg, isErased) <- app.args.lazyZip(methType.erasedParams) do
+              if isErased then
+                if methType.isResultDependent then
+                  Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
           def app1 =
             // reverse order of transforming args and fun. This way, we get a chance to see other
             // well-formedness errors before reporting errors in possible inferred type args of fun.
@@ -499,7 +477,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           registerIfHasMacroAnnotations(tree)
           checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
-          val tree1 = cpy.ValDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt), rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          val tree1 = cpy.ValDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt))
           if tree1.removeAttachment(desugar.UntupledParam).isDefined then
             checkStableSelection(tree.rhs)
           processValOrDefDef(super.transform(tree1))
@@ -508,7 +486,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
           annotateContextResults(tree)
-          val tree1 = cpy.DefDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt), rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          val tree1 = cpy.DefDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt))
           processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
         case tree: TypeDef =>
           registerIfHasMacroAnnotations(tree)
@@ -632,12 +610,6 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       Checking.checkAndAdaptExperimentalImports(trees)
       super.transformStats(trees, exprOwner, wrapResult)
 
-    /** Transforms the rhs tree into a its default tree if it is in an `erased` val/def.
-     *  Performed to shrink the tree that is known to be erased later.
-     */
-    private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(using Context) =
-      if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
-
     private def registerNeedsInlining(tree: Tree)(using Context): Unit =
       if tree.symbol.is(Inline) && !Inlines.inInlineMethod && !ctx.mode.is(Mode.NoInline) then
         ctx.compilationUnit.needsInlining = true

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

@@ -37,8 +37,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
 
   override def description: String = ResolveSuper.description
 
-  override def runsAfter: Set[String] = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
-                               PruneErasedDefs.name) // Erased decls make `isCurrent` work incorrectly
+  override def runsAfter: Set[String] = Set(ElimByName.name) // verified empirically, need to figure out what the reason is.
 
   override def changesMembers: Boolean = true // the phase adds super accessors
 

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

@@ -63,7 +63,7 @@ class CompileProgressSpecification {
         "staging",
         "splicing",
         "pickleQuotes",
-        "MegaPhase{pruneErasedDefs,...,arrayConstructors}",
+        "MegaPhase{uninitialized,...,arrayConstructors}",
         "erasure",
         "constructors",
         "genBCode"

sbt-bridge/test/xsbt/CompileProgressSpecification.scala

@@ -18,6 +18,23 @@
 # - description (can be multi-line)
 # '' sign
 # ------------------------------------------
+0
+macro-late-suspend/UsesTest.scala
+example
+UsesTest$package
+Object
+example.UsesTest$package
+<init>
+22
+22
+3
+<none>
+Literal
+true
+0
+false
+
+
 1
 macro-late-suspend/VisitorMacros.scala
 example
@@ -69,20 +86,3 @@ false
 false
 mkVisitorType[Test]
 
-4
-macro-late-suspend/UsesTest.scala
-example
-UsesTest$package
-Object
-example.UsesTest$package
-<init>
-22
-22
-3
-<none>
-Literal
-true
-0
-false
-
-

tests/coverage/pos/macro-late-suspend/test.scoverage.check

@@ -0,0 +1,23 @@
+import language.experimental.erasedDefinitions
+
+inline def id[T](x: T) = x
+
+class C()
+
+def foo[T](erased x: T): Unit = ()
+
+class Pair[A, B](x: A, y: B)
+
+
+def Test =
+  foo(C())
+  foo(id(C()))
+  foo(Pair(C(), C()))
+  foo(Pair(C(), 22))
+  foo(Pair(C(), "hello" + "world"))
+  foo(id(Pair(id(C()), id("hello" + "world"))))
+
+
+
+
+