Remove untpd.EnumGetters

no longer special case some definitions for indexing after the
parents of a class are discovered.

Extend invalidateIfClashingSynthetic to cover ordinal override
from java.lang.Enum

Author: bishabosha

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -58,6 +58,9 @@ object desugar {
     case _ => false
   }
 
+  def isRetractableCaseClassOrEnumMethodName(name: Name)(using Context): Boolean =
+    isRetractableCaseClassMethodName(name) || name == nme.ordinal
+
   /** Is `name` the name of a method that is added unconditionally to case classes? */
   def isDesugaredCaseClassMethodName(name: Name)(using Context): Boolean =
     isRetractableCaseClassMethodName(name) || name.isSelectorName
@@ -485,8 +488,8 @@ object desugar {
         val enumImport =
           Import(enumCompanionRef, enumCases.flatMap(caseIds).map(ImportSelector(_)))
         val enumLabelDef = DesugarEnums.enumLabelMeth(EmptyTree)
-        val enumGetters = EnumGetters() // optionally generate ordinal method
-        (enumImport :: enumGetters :: enumLabelDef :: enumStats, enumCases, enumCompanionRef)
+        val ordinalDef = DesugarEnums.ordinalMeth(EmptyTree).withAddedFlags(Synthetic)
+        (enumImport :: ordinalDef :: enumLabelDef :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)
     }
@@ -891,9 +894,6 @@ object desugar {
     }
   }
 
-  def enumGetters(getters: EnumGetters)(using Context): Tree =
-   flatTree(DesugarEnums.optionalOrdinalMethod).withSpan(getters.span)
-
   /** Transform extension construct to list of extension methods */
   def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {
     for mdef <- ext.methods yield

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -322,10 +322,6 @@ object DesugarEnums {
       (ordinal, Nil)
   }
 
-  def optionalOrdinalMethod(using Context): List[Tree] =
-    if isJavaEnum then Nil
-    else ordinalMeth(EmptyTree) :: Nil
-
   def param(name: TermName, typ: Type)(using Context): ValDef = param(name, TypeTree(typ))
   def param(name: TermName, tpt: Tree)(using Context): ValDef = ValDef(name, tpt, EmptyTree).withFlags(Param)
 

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -116,7 +116,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree
   case class ExtMethods(tparams: List[TypeDef], vparamss: List[List[ValDef]], methods: List[DefDef])(implicit @constructorOnly src: SourceFile) extends Tree
   case class MacroTree(expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
-  case class EnumGetters()(implicit @constructorOnly src: SourceFile) extends Tree
 
   case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
     // TODO: Make bound a typed tree?
@@ -701,7 +700,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Export(tree)(transform(expr), selectors)
       case ExtMethods(tparams, vparamss, methods) =>
         cpy.ExtMethods(tree)(transformSub(tparams), vparamss.mapConserve(transformSub(_)), transformSub(methods))
-      case enums: EnumGetters => enums
       case ImportSelector(imported, renamed, bound) =>
         cpy.ImportSelector(tree)(transformSub(imported), transform(renamed), transform(bound))
       case Number(_, _) | TypedSplice(_) =>
@@ -763,8 +761,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, expr)
       case ExtMethods(tparams, vparamss, methods) =>
         this(vparamss.foldLeft(this(x, tparams))(apply), methods)
-      case EnumGetters() =>
-        x
       case ImportSelector(imported, renamed, bound) =>
         this(this(this(x, imported), renamed), bound)
       case Number(_, _) =>

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

@@ -168,7 +168,8 @@ object SymUtils {
     self
   }
 
-  def isScalaEnum(using Context): Boolean = self.is(Enum, butNot=JavaDefined)
+  def isEnum(using Context): Boolean = self.is(Enum, butNot=JavaDefined)
+  def isEnumClass(using Context): Boolean = isEnum && !self.is(Case)
 
   /** Does this symbol refer to anonymous classes synthesized by enum desugaring? */
   def isEnumAnonymClass(using Context): Boolean =

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

@@ -94,8 +94,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     lazy val accessors =
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
-    val isEnumCase = clazz.classParents.exists(_.classSymbol.isScalaEnum)
-    val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
+    val isEnumCase = clazz.isEnum || clazz.classParents.exists(_.classSymbol.isEnum)
+    val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.isEnum
     val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =

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

@@ -343,20 +343,17 @@ class Namer { typer: Typer =>
         tree.pushAttachment(ExpandedTree, expanded)
       }
     tree match {
-      case tree: DefTree     => record(desugar.defTree(tree))
-      case tree: PackageDef  => record(desugar.packageDef(tree))
-      case tree: ExtMethods  => record(desugar.extMethods(tree))
-      case tree: EnumGetters => record(desugar.enumGetters(tree))
-      case _                 =>
+      case tree: DefTree    => record(desugar.defTree(tree))
+      case tree: PackageDef => record(desugar.packageDef(tree))
+      case tree: ExtMethods => record(desugar.extMethods(tree))
+      case _                =>
     }
   }
 
   /** The expanded version of this tree, or tree itself if not expanded */
   def expanded(tree: Tree)(using Context): Tree = tree match {
-    case _: DefTree | _: PackageDef | _: ExtMethods | _: EnumGetters =>
-      tree.attachmentOrElse(ExpandedTree, tree)
-    case _ =>
-      tree
+    case _: DefTree | _: PackageDef | _: ExtMethods => tree.attachmentOrElse(ExpandedTree, tree)
+    case _ => tree
   }
 
   /** For all class definitions `stat` in `xstats`: If the companion class is
@@ -746,21 +743,34 @@ class Namer { typer: Typer =>
     }
 
     /** Invalidate `denot` by overwriting its info with `NoType` if
-     *  `denot` is a compiler generated case class method that clashes
-     *  with a user-defined method in the same scope with a matching type.
+     *  one of the following holds:
+     *  - `denot` is a compiler generated case class method that clashes
+     *     with a user-defined method in the same scope with a matching type.
+     *  - `denot` is a compiler generated `ordinal` method that would override
+     *    `ordinal` declared in `java.lang.Enum`
      */
     private def invalidateIfClashingSynthetic(denot: SymDenotation): Unit = {
       def isCaseClass(owner: Symbol) =
         owner.isClass && {
           if (owner.is(Module)) owner.linkedClass.is(CaseClass)
           else owner.is(CaseClass)
         }
-      val isClashingSynthetic =
-        denot.is(Synthetic) &&
-        desugar.isRetractableCaseClassMethodName(denot.name) &&
-        isCaseClass(denot.owner) &&
-        denot.owner.info.decls.lookupAll(denot.name).exists(alt =>
+      def isJavaEnumBaseClass(owner: Symbol) =
+        owner.isClass && owner.isEnumClass && owner.derivesFrom(defn.JavaEnumClass)
+      def firstParentCls(owner: Symbol) =
+        owner.asClass.classParents.head.classSymbol
+      def findMatch(owner: Symbol) =
+        owner.info.decls.lookupAll(denot.name).exists(alt =>
           alt != denot.symbol && alt.info.matchesLoosely(denot.info))
+      def clashingCaseClassMethod =
+        desugar.isRetractableCaseClassMethodName(denot.name)
+        && isCaseClass(denot.owner)
+        && findMatch(denot.owner)
+      def clashingEnumMethod =
+        denot.name == nme.ordinal
+        && isJavaEnumBaseClass(denot.owner)
+        && findMatch(firstParentCls(denot.owner))
+      val isClashingSynthetic = denot.is(Synthetic) && (clashingCaseClassMethod || clashingEnumMethod)
       if (isClashingSynthetic) {
         typr.println(i"invalidating clashing $denot in ${denot.owner}")
         denot.markAbsent()
@@ -928,21 +938,11 @@ class Namer { typer: Typer =>
 
     val TypeDef(name, impl @ Template(constr, _, self, _)) = original
 
-    private val (params, restOfBody): (List[Tree], List[Tree]) = impl.body.span {
+    private val (params, rest): (List[Tree], List[Tree]) = impl.body.span {
       case td: TypeDef => td.mods.is(Param)
       case vd: ValDef => vd.mods.is(ParamAccessor)
       case _ => false
     }
-    private val (restAfterParents, rest): (List[Tree], List[Tree]) =
-      if original.mods.isEnumClass then
-        // in Desugar.scala, desugaring an enum class definition fixes the
-        // first and second statements in the body to be `imports` and `getters`.
-        // `imports` is an import list of the enum cases from the companion of `cls`
-        // `getters` will expand to `def ordinal: Int` if the parents of `cls` are not java.lang.Enum
-        val (imports :: getters :: Nil, stats): @unchecked = restOfBody.splitAt(2)
-        (getters :: Nil, imports :: stats)
-      else
-        (Nil, restOfBody)
 
     def init(): Context = index(params)
 
@@ -1209,7 +1209,6 @@ class Namer { typer: Typer =>
       cls.setNoInitsFlags(parentsKind(parents), untpd.bodyKind(rest))
       if (cls.isNoInitsClass) cls.primaryConstructor.setFlag(StableRealizable)
       processExports(using localCtx)
-      index(restAfterParents)(using localCtx)
     }
   }
 

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

@@ -1941,11 +1941,10 @@ class Typer extends Namer
   }
 
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = {
-    if (!sym.info.exists) { // it's a discarded synthetic case class method, drop it
-      assert(sym.is(Synthetic) && desugar.isRetractableCaseClassMethodName(sym.name))
+    if !sym.info.exists then // it's a discarded synthetic case class method, or ordinal method drop it
+      assert(sym.is(Synthetic) && desugar.isRetractableCaseClassOrEnumMethodName(sym.name))
       sym.owner.info.decls.openForMutations.unlink(sym)
       return EmptyTree
-    }
     val DefDef(name, tparams, vparamss, tpt, _) = ddef
     completeAnnotations(ddef, sym)
     val tparams1 = tparams.mapconserve(typed(_).asInstanceOf[TypeDef])
@@ -2123,7 +2122,7 @@ class Typer extends Namer
         .withType(dummy.termRef)
       if (!cls.isOneOf(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.sourcePos.withSpan(cdef.nameSpan))
-      if cls.isScalaEnum || firstParentTpe.classSymbol.isScalaEnum then
+      if cls.isEnum || firstParentTpe.classSymbol.isEnum then
         checkEnum(cdef, cls, firstParent)
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
 
@@ -2636,9 +2635,6 @@ class Typer extends Namer
       case (stat: untpd.ExtMethods) :: rest =>
         val xtree = stat.removeAttachment(ExpandedTree).get
         traverse(xtree :: rest)
-      case (stat: untpd.EnumGetters) :: rest =>
-        val xtree = stat.removeAttachment(ExpandedTree).get
-        traverse(xtree :: rest)
       case stat :: rest =>
         val stat1 = typed(stat)(using ctx.exprContext(stat, exprOwner))
         checkStatementPurity(stat1)(stat, exprOwner)

tests/neg/enumsLabel-singleimpl.scala

@@ -8,8 +8,8 @@ enum Labelled {
 
 enum Ordinalled {
 
-  case A // error: double definition of method ordinal: => Int
+  case A
 
-  def ordinal: Int = -1
+  def ordinal: Int = -1 // error: double definition of method ordinal: => Int
 
 }