Refine widening of enumCases

Widen whenever it is possible to do so while still conforming
to expected type.

Author: odersky

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

@@ -286,18 +286,53 @@ trait ConstraintHandling {
     }
   }
 
+  /** If `tp` is an intersection such that some operands are super trait instances
+   *  and others are not, replace as many super trait instances as possible with Any
+   *  as long as the result is still a subtype of `bound`. But fall back to the
+   *  original type if the resulting widened type is a supertype of all dropped
+   *  types (since in this case the type was not a true intersection of super traits
+   *  and other types to start with).
+   */
+  def dropSuperTraits(tp: Type, bound: Type)(using Context): Type =
+    var kept: Set[Type] = Set()      // types to keep since otherwise bound would not fit
+    var dropped: List[Type] = List() // the types dropped so far, last one on top
+
+    def dropOneSuperTrait(tp: Type): Type =
+      val tpd = tp.dealias
+      if tpd.typeSymbol.isSuperTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
+        dropped = tpd :: dropped
+        defn.AnyType
+      else tpd match
+        case AndType(tp1, tp2) =>
+          val tp1w = dropOneSuperTrait(tp1)
+          if tp1w ne tp1 then tp1w & tp2
+          else
+            val tp2w = dropOneSuperTrait(tp2)
+            if tp2w ne tp2 then tp1 & tp2w
+            else tpd
+        case _ =>
+          tp
+
+    def recur(tp: Type): Type =
+      val tpw = dropOneSuperTrait(tp)
+      if tpw eq tp then tp
+      else if tpw <:< bound then recur(tpw)
+      else
+        kept += dropped.head
+        dropped = dropped.tail
+        recur(tp)
+
+    val tpw = recur(tp)
+    if (tpw eq tp) || dropped.forall(_ frozen_<:< tpw) then tp else tpw
+  end dropSuperTraits
+
   /** Widen inferred type `inst` with upper `bound`, according to the following rules:
    *   1. If `inst` is a singleton type, or a union containing some singleton types,
    *      widen (all) the singleton type(s), provided the result is a subtype of `bound`
    *      (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 such that some operands are super trait instances
-   *      and others are not, replace as many super trait instances as possible with Any
-   *      as long as the result is still a subtype of `bound`. But fall back to the
-   *      original type if the resulting widened type is a supertype of all dropped
-   *      types (since in this case the type was not a true intersection of super traits
-   *      and other types to start with).
+   *   3. drop super traits from intersections (see @dropSuperTraits)
    *
    *  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,
@@ -308,40 +343,6 @@ trait ConstraintHandling {
    * as those could leak the annotation to users (see run/inferred-repeated-result).
    */
   def widenInferred(inst: Type, bound: Type)(using Context): Type =
-
-    def dropSuperTraits(tp: Type): Type =
-      var kept: Set[Type] = Set()      // types to keep since otherwise bound would not fit
-      var dropped: List[Type] = List() // the types dropped so far, last one on top
-
-      def dropOneSuperTrait(tp: Type): Type =
-        val tpd = tp.dealias
-        if tpd.typeSymbol.isSuperTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
-          dropped = tpd :: dropped
-          defn.AnyType
-        else tpd match
-          case AndType(tp1, tp2) =>
-            val tp1w = dropOneSuperTrait(tp1)
-            if tp1w ne tp1 then tp1w & tp2
-            else
-              val tp2w = dropOneSuperTrait(tp2)
-              if tp2w ne tp2 then tp1 & tp2w
-              else tpd
-          case _ =>
-            tp
-
-      def recur(tp: Type): Type =
-        val tpw = dropOneSuperTrait(tp)
-        if tpw eq tp then tp
-        else if tpw <:< bound then recur(tpw)
-        else
-          kept += dropped.head
-          dropped = dropped.tail
-          recur(tp)
-
-      val tpw = recur(tp)
-      if (tpw eq tp) || dropped.forall(_ frozen_<:< tpw) then tp else tpw
-    end dropSuperTraits
-
     def widenOr(tp: Type) =
       val tpw = tp.widenUnion
       if (tpw ne tp) && (tpw <:< bound) then tpw else tp
@@ -356,7 +357,7 @@ trait ConstraintHandling {
 
     val wideInst =
       if isSingleton(bound) then inst
-      else dropSuperTraits(widenOr(widenSingle(inst)))
+      else dropSuperTraits(widenOr(widenSingle(inst)), bound)
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)

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

@@ -2625,6 +2625,9 @@ object TypeComparer {
   def widenInferred(inst: Type, bound: Type)(using Context): Type =
     comparing(_.widenInferred(inst, bound))
 
+  def dropSuperTraits(tp: Type, bound: Type)(using Context): Type =
+    comparing(_.dropSuperTraits(tp, bound))
+
   def constrainPatternType(pat: Type, scrut: Type)(using Context): Boolean =
     comparing(_.constrainPatternType(pat, scrut))
 

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

@@ -1123,12 +1123,14 @@ trait Applications extends Compatibility {
     def isEnumApply = sym.name == nme.apply && sym.owner.linkedClass.isEnumCase
     if sym.is(Synthetic) && (isEnumApply || isEnumCopy)
        && tree.tpe.classSymbol.isEnumCase
-       && !pt.isInstanceOf[FunProto]
-       && !pt.classSymbol.isEnumCase
+       && tree.tpe.widen.isValueType
     then
-      Typed(tree, TypeTree(tree.tpe.parents.reduceLeft(TypeComparer.andType(_, _))))
-    else
-      tree
+      val widened = TypeComparer.dropSuperTraits(
+        tree.tpe.parents.reduceLeft(TypeComparer.andType(_, _)),
+        pt)
+      if widened <:< pt then Typed(tree, TypeTree(widened))
+      else tree
+    else tree
 
   /** Does `state` contain a  "NotAMember" or "MissingIdent" message as
    *  first pending error message? That message would be

tests/pos/enum-widen.scala

@@ -13,4 +13,9 @@ object test:
   x = None
   xc = None
 
+  enum Nat:
+    case Z
+    case S[N <: Z.type | S[_]](pred: N)
+  import Nat._
 
+  val two = S(S(Z))