Strip EnumValue parent from inferred types

We now strip EnumValue parents from inferred types, unless
they are required by the bound. This is analogous to widen
unions and singletons. It should be generalized to more
types, not just EnumValue.

Author: odersky

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

@@ -300,6 +300,8 @@ trait ConstraintHandling[AbstractContext] {
    *      (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint)
    *   2. If `inst` is a union type, approximate the union type from above by an intersection
    *      of all common base types, provided the result is a subtype of `bound`.
+   *   3. If `inst` is an intersection with some protected base types, drop
+   *      the protected base types from the intersection, provided the result is a subtype of `bound`.
    *
    *  Don't do these widenings if `bound` is a subtype of `scala.Singleton`.
    *  Also, if the result of these widenings is a TypeRef to a module class,
@@ -309,26 +311,43 @@ trait ConstraintHandling[AbstractContext] {
    * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it,
    * as those could leak the annotation to users (see run/inferred-repeated-result).
    */
-  def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type = {
-    def widenOr(tp: Type) = {
+  def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type =
+
+    def isProtected(tp: Type) = tp.typeSymbol == defn.EnumValueClass // for now, to be generalized later
+
+    def dropProtected(tp: Type): Type = tp.dealias match
+      case tp @ AndType(tp1, tp2) =>
+        if isProtected(tp1) then tp2
+        else if isProtected(tp2) then tp1
+        else tp.derivedAndType(dropProtected(tp1), dropProtected(tp2))
+      case _ =>
+        tp
+
+    def widenProtected(tp: Type) =
+      val tpw = dropProtected(tp)
+      if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+
+    def widenOr(tp: Type) =
       val tpw = tp.widenUnion
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
-    }
-    def widenSingle(tp: Type) = {
+
+    def widenSingle(tp: Type) =
       val tpw = tp.widenSingletons
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
-    }
+
     def isSingleton(tp: Type): Boolean = tp match
       case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
+
     val wideInst =
-      if isSingleton(bound) then inst else widenOr(widenSingle(inst))
+      if isSingleton(bound) then inst
+      else widenProtected(widenOr(widenSingle(inst)))
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)
       case _ =>
         wideInst.dropRepeatedAnnot
-  }
+  end widenInferred
 
   /** The instance type of `param` in the current constraint (which contains `param`).
    *  If `fromBelow` is true, the instance type is the lub of the parameter's

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

@@ -639,6 +639,7 @@ class Definitions {
   @tu lazy val EnumClass: ClassSymbol = ctx.requiredClass("scala.Enum")
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
 
+  @tu lazy val EnumValueClass: ClassSymbol = ctx.requiredClass("scala.EnumValue")
   @tu lazy val EnumValuesClass: ClassSymbol = ctx.requiredClass("scala.runtime.EnumValues")
   @tu lazy val ProductClass: ClassSymbol = ctx.requiredClass("scala.Product")
     @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)

tests/neg/enumvalues.scala

@@ -0,0 +1,11 @@
+enum Color:
+  case Red, Green, Blue
+
+@main def Test(c: Boolean) =
+  // These currently give errors. But maybe we should make the actual
+  // enum values carry the `EnumValue` trait, and only strip it from
+  // user-defined vals and defs?
+  val x: EnumValue = if c then Color.Red else Color.Blue // error // error
+  val y: EnumValue = Color.Green        // error
+
+