fix: Drop copied parent refinements before generating bytecode (#21733)

Refinements are copied over from parents, because they might be needed
for tracked members that should have more specific types in the child.
These members are generated without an implementation and should not be
used in runtime.

possible fix for #21213

---------

Co-authored-by: Dale Wijnand <[email protected]>
Co-authored-by: Matt Bovel <[email protected]>

Author: 3 people

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

@@ -132,6 +132,7 @@ class Compiler {
          new ElimStaticThis,         // Replace `this` references to static objects by global identifiers
          new CountOuterAccesses) ::  // Identify outer accessors that can be dropped
     List(new DropOuterAccessors,     // Drop unused outer accessors
+         new DropParentRefinements,  // Drop parent refinements from a template
          new CheckNoSuperThis,       // Check that supercalls don't contain references to `this`
          new Flatten,                // Lift all inner classes to package scope
          new TransformWildcards,     // Replace wildcards with default values

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

@@ -0,0 +1,35 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.typer.Typer
+
+object DropParentRefinements:
+  val name: String = "dropParentRefinements"
+  val description: String = "drop parent refinements from a template"
+
+/** Drop parent refinements from a template, as they are generated without
+  * an implementation. These refinements are unusally required for tracked
+  * members with more specific types.
+  */
+class DropParentRefinements extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import tpd.*
+
+  override def phaseName: String = DropParentRefinements.name
+
+  override def description: String = DropParentRefinements.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(CountOuterAccesses.name)
+
+  override def changesMembers: Boolean = true // the phase drops parent refinements
+
+  override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree =
+    val newBody = tree.body.filter(!_.hasAttachment(Typer.RefinementFromParent))
+    tree.body.foreach { member =>
+      if member.hasAttachment(Typer.RefinementFromParent) then
+        member.symbol.dropAfter(thisPhase)
+    }
+    cpy.Template(tree)(body = newBody)

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

@@ -103,7 +103,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
   override def transformValDef(tree: ValDef)(using Context): Tree =
     val sym = tree.symbol
     if !sym.is(Method) then return tree
-    val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span)
+    val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span).withAttachmentsFrom(tree)
     if !sym.is(Mutable) then return getterDef
     ensureSetter(sym.asTerm)
     if !newSetters.contains(sym.setter) then return getterDef

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

@@ -877,16 +877,16 @@ class Namer { typer: Typer =>
     protected def addAnnotations(sym: Symbol): Unit = original match {
       case original: untpd.MemberDef =>
         lazy val annotCtx = annotContext(original, sym)
-        original.setMods: 
+        original.setMods:
           original.mods.withAnnotations :
-            original.mods.annotations.mapConserve: annotTree =>  
+            original.mods.annotations.mapConserve: annotTree =>
               val cls = typedAheadAnnotationClass(annotTree)(using annotCtx)
               if (cls eq sym)
                 report.error(em"An annotation class cannot be annotated with iself", annotTree.srcPos)
                 annotTree
               else
-                val ann = 
-                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass) 
+                val ann =
+                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass)
                   else annotTree
                 val ann1 = Annotation.deferred(cls)(typedAheadExpr(ann)(using annotCtx))
                 sym.addAnnotation(ann1)

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

@@ -78,6 +78,9 @@ object Typer {
   /** An attachment for GADT constraints that were inferred for a pattern. */
   val InferredGadtConstraints = new Property.StickyKey[core.GadtConstraint]
 
+  /** Indicates that a definition was copied over from the parent refinements */
+  val RefinementFromParent = new Property.StickyKey[Unit]
+
   /** An attachment on a Select node with an `apply` field indicating that the `apply`
    *  was inserted by the Typer.
    */
@@ -3071,7 +3074,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             ( if sym.isType then TypeDef(sym.asType)
               else if sym.is(Method) then DefDef(sym.asTerm)
               else ValDef(sym.asTerm)
-            ).withSpan(impl.span.startPos)
+            ).withSpan(impl.span.startPos).withAttachment(RefinementFromParent, ())
           body ++ refinements
         case None =>
           body

tests/printing/transformed/lazy-vals-legacy.check

@@ -1,4 +1,4 @@
-[[syntax trees at end of MegaPhase{dropOuterAccessors, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala
+[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala
 package <empty> {
   @SourceFile("tests/printing/transformed/lazy-vals-legacy.scala") final module
     class A extends Object {

tests/printing/transformed/lazy-vals-new.check

@@ -1,4 +1,4 @@
-[[syntax trees at end of MegaPhase{dropOuterAccessors, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala
+[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala
 package <empty> {
   @SourceFile("tests/printing/transformed/lazy-vals-new.scala") final module
     class A extends Object {

tests/run/i21213-min.check

@@ -0,0 +1 @@
+bar

tests/run/i21213-min.scala

@@ -0,0 +1,9 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+sealed abstract class Foo(tracked val discriminator: String)
+class Bar extends Foo("bar")
+
+val bar: Foo = Bar()
+object Test extends App:
+  println(bar.discriminator)

tests/run/i21213.check

@@ -0,0 +1 @@
+bar

tests/run/i21213.scala

@@ -0,0 +1,10 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+enum Foo(tracked val discriminator: String):
+  case Bar() extends Foo("bar")
+  case Baz() extends Foo("baz")
+
+val bar: Foo = Foo.Bar()
+object Test extends App:
+  println(bar.discriminator)