Combine new widenInferred scheme with singleton unions

Author: odersky

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

@@ -272,50 +272,24 @@ trait ConstraintHandling[AbstractContext] {
     }
   }
 
-  /** Widen inferred type `tp` with upper bound `bound`, according to the following rules:
-   *   1. If `tp` is a singleton type, yet `bound` is not a singleton type, nor a subtype
-   *      of `scala.Singleton`, widen `tp`.
-   *   2. If `tp` is a union type, yet upper bound is not a union type,
-   *      approximate the union type from above by an intersection of all common base types.
+  /** 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), provied 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, provied the result is a subtype of `bound`.
    *
    * 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(tp: Type, bound: Type)(implicit actx: AbstractContext): Type = {
-    def isMultiSingleton(tp: Type): Boolean = tp.stripAnnots match {
-      case tp: SingletonType => true
-      case AndType(tp1, tp2) => isMultiSingleton(tp1) | isMultiSingleton(tp2)
-      case OrType(tp1, tp2) => isMultiSingleton(tp1) & isMultiSingleton(tp2)
-      case tp: TypeRef => isMultiSingleton(tp.info.hiBound)
-      case tp: TypeVar => isMultiSingleton(tp.underlying)
-      case tp: TypeParamRef => isMultiSingleton(bounds(tp).hi)
-      case _ => false
-    }
-    def isOrType(tp: Type): Boolean = tp.dealias match {
-      case tp: OrType => true
-      case tp: RefinedOrRecType => isOrType(tp.parent)
-      case AndType(tp1, tp2) => isOrType(tp1) | isOrType(tp2)
-      case WildcardType(bounds: TypeBounds) => isOrType(bounds.hi)
-      case _ => false
-    }
-    def widenOr(tp: Type) =
-      if (isOrType(tp) && !isOrType(bound)) tp.widenUnion
-      else tp
-    def widenSingle(tp: Type) =
-      if (isMultiSingleton(tp) && !isMultiSingleton(bound) &&
-          !isSubTypeWhenFrozen(bound, defn.SingletonType)) tp.widen
-      else tp
-    widenOr(widenSingle(tp)).dropRepeatedAnnot
-  }
-
-  def widenInferred2(inst: Type, param: TypeParamRef)(implicit actx: AbstractContext): Type = {
+  def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type = {
     def widenSingle(tp: Type) = {
-      val tpw = tp.widen
-      if ((tpw ne tp) && tpw <:< param) tpw else tp
+      val tpw = tp.widenSingletons
+      if ((tpw ne tp) && tpw <:< bound) tpw else tp
     }
     def widenOr(tp: Type) = {
       val tpw = tp.widenUnion
-      if ((tpw ne tp) && tpw <:< param) tpw else tp
+      if ((tpw ne tp) && tpw <:< bound) tpw else tp
     }
     widenOr(widenSingle(inst)).dropRepeatedAnnot
   }
@@ -328,7 +302,7 @@ trait ConstraintHandling[AbstractContext] {
    */
   def instanceType(param: TypeParamRef, fromBelow: Boolean)(implicit actx: AbstractContext): Type = {
     val inst = approximation(param, fromBelow).simplified
-    if (fromBelow) widenInferred2(inst, /*constraint.fullUpperBound*/(param)) else inst
+    if (fromBelow) widenInferred(inst, param) else inst
   }
 
   /** Constraint `c1` subsumes constraint `c2`, if under `c2` as constraint we have

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

@@ -1525,7 +1525,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
   /** The greatest lower bound of a list types */
   final def glb(tps: List[Type]): Type = ((AnyType: Type) /: tps)(glb)
 
-  def widenInUnions(implicit ctx: Context): Boolean = ctx.scala2Mode || ctx.erasedTypes || true
+  def widenInUnions(implicit ctx: Context): Boolean = ctx.scala2Mode || ctx.erasedTypes
 
   /** The least upper bound of two types
    *  @param canConstrain  If true, new constraints might be added to simplify the lub.

tests/pos/i6288.scala

@@ -0,0 +1,15 @@
+object A {
+  opaque type T = 3
+  object T {
+    val x: T = 3
+  }
+}
+
+object O {
+  val x = 3
+  opaque type T = x.type
+  object T {
+    def wrap(a: x.type): T = a   // Error
+    def unwrap(a: T): x.type = a // OK
+  }
+}