separate widenEnumClass logic to own method

Author: bishabosha

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

@@ -527,12 +527,6 @@ object desugar {
     // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
     val classTypeRef = appliedRef(classTycon)
 
-    def applyResultTpt =
-      if isEnumCase then
-        classTypeRef
-      else
-        TypeTree()
-
     // a reference to `enumClass`, with type parameters coming from the case constructor
     lazy val enumClassTypeRef =
       if (enumClass.typeParams.isEmpty)
@@ -611,7 +605,7 @@ object desugar {
             cpy.ValDef(vparam)(rhs = copyDefault(vparam)))
           val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
             cpy.ValDef(vparam)(rhs = EmptyTree))
-          DefDef(nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, applyResultTpt, creatorExpr)
+          DefDef(nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, classTypeRef, creatorExpr)
             .withMods(Modifiers(Synthetic | constr1.mods.flags & copiedAccessFlags, constr1.mods.privateWithin)) :: Nil
         }
       }
@@ -704,7 +698,7 @@ object desugar {
             val appParamss =
               derivedVparamss.nestedZipWithConserve(constrVparamss)((ap, cp) =>
                 ap.withMods(ap.mods | (cp.mods.flags & HasDefault)))
-            DefDef(nme.apply, derivedTparams, appParamss, applyResultTpt, creatorExpr)
+            DefDef(nme.apply, derivedTparams, appParamss, classTypeRef, creatorExpr)
               .withMods(appMods) :: Nil
           }
         val unapplyMeth = {
@@ -714,7 +708,7 @@ object desugar {
           val methName = if (hasRepeatedParam) nme.unapplySeq else nme.unapply
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
-          val unapplyResTp = if (arity == 0) Literal(Constant(true)) else applyResultTpt
+          val unapplyResTp = if arity == 0 then Literal(Constant(true)) else classTypeRef
           DefDef(methName, derivedTparams, (unapplyParam :: Nil) :: Nil, unapplyResTp, unapplyRHS)
             .withMods(synthetic)
         }

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

@@ -346,6 +346,10 @@ trait ConstraintHandling {
       val tpw = tp.widenUnion
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
 
+    def widenEnum(tp: Type) =
+      val tpw = tp.widenEnumClass
+      if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+
     def widenSingle(tp: Type) =
       val tpw = tp.widenSingletons
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
@@ -354,12 +358,13 @@ trait ConstraintHandling {
       case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
 
-    def isEnumBound(tp: Type): Boolean =
-      bound.isValueType && bound.typeSymbol.is(Enum, butNot=JavaDefined) && tp <:< bound
+    def isEnum(tp: Type): Boolean = tp match
+      case WildcardType(optBounds) => optBounds.exists && isEnum(optBounds.bounds.hi)
+      case _ => tp.typeSymbol.is(Enum, butNot=JavaDefined)
 
     val wideInst =
-      if isSingleton(bound) || isEnumBound(bound) then inst
-      else dropSuperTraits(widenOr(widenSingle(inst)))
+      if isSingleton(bound) || isEnum(bound) then inst
+      else dropSuperTraits(widenOr(widenEnum(widenSingle(inst))))
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)

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

@@ -1173,6 +1173,13 @@ object Types {
         tp
     }
 
+    def widenEnumClass(using Context): Type = dealias match {
+      case tp: (TypeRef | AppliedType) if tp.typeSymbol.isAllOf(EnumCase) =>
+        tp.parents.head
+      case _ =>
+        this
+    }
+
     /** Widen all top-level singletons reachable by dealiasing
      *  and going to the operands of & and |.
      *  Overridden and cached in OrType.