Special case dropping EnumValue in Namer

We now drop EnumValue just when inferring types of enum cases. This can be
done unconditionally since in any case every enum case extends Enum, which
extends Product and Serializable. EnumValue is just an invisible implementation
bundle.

This means we disable for now the more general handling in widenInferred.

Author: odersky

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

@@ -306,7 +306,7 @@ object DesugarEnums {
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Simple)
       val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
-      val vdef = ValDef(name, TypeTree(), creator).withMods(mods.withAddedFlags(EnumValue, span))
+      val vdef = ValDef(name, enumClassRef, creator).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }
 }

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -341,7 +341,10 @@ trait ConstraintHandling[AbstractContext] {
 
     val wideInst =
       if isSingleton(bound) then inst
-      else widenProtected(widenOr(widenSingle(inst)))
+      else /*widenProtected*/(widenOr(widenSingle(inst)))
+        // widenProtected is currently not called since it's special cased in `dropEnumValue`
+        // in `Namer`. It's left in here in case we want to generalize the scheme to other
+        // "protected inheritance" classes.
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -438,7 +438,7 @@ object Flags {
    *  TODO: Should check that FromStartFlags do not change in completion
    */
   val FromStartFlags: FlagSet = commonFlags(
-    Module, Package, Deferred, Method, Case,
+    Module, Package, Deferred, Method, Case, Enum,
     HigherKinded, Param, ParamAccessor,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,

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

@@ -1439,6 +1439,17 @@ class Namer { typer: Typer =>
       // println(s"owner = ${sym.owner}, decls = ${sym.owner.info.decls.show}")
       def isInlineVal = sym.isOneOf(FinalOrInline, butNot = Method | Mutable)
 
+      def isEnumValue(tp: Type) = tp.typeSymbol == defn.EnumValueClass
+
+      // Drop EnumValue parents from inferred types of enum constants
+      def dropEnumValue(tp: Type): Type = tp.dealias match
+        case tp @ AndType(tp1, tp2) =>
+          if isEnumValue(tp1) then tp2
+          else if isEnumValue(tp2) then tp1
+          else tp.derivedAndType(dropEnumValue(tp1), dropEnumValue(tp2))
+        case _ =>
+          tp
+
       // Widen rhs type and eliminate `|' but keep ConstantTypes if
       // definition is inline (i.e. final in Scala2) and keep module singleton types
       // instead of widening to the underlying module class types.
@@ -1447,7 +1458,9 @@ class Namer { typer: Typer =>
       def widenRhs(tp: Type): Type =
         tp.widenTermRefExpr.simplified match
           case ctp: ConstantType if isInlineVal => ctp
-          case tp => ctx.typeComparer.widenInferred(tp, rhsProto)
+          case tp =>
+            val tp1 = ctx.typeComparer.widenInferred(tp, rhsProto)
+            if sym.is(Enum) then dropEnumValue(tp1) else tp1
 
       // Replace aliases to Unit by Unit itself. If we leave the alias in
       // it would be erased to BoxedUnit.