Treat soft and hard unions differently when widening

Author: odersky

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

@@ -426,6 +426,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           case Some(b) => return b
           case None =>
 
+        def widenOK =
+          (tp2.widenSingletons eq tp2)
+          && (tp1.widenSingletons ne tp1)
+          && recur(tp1.widenSingletons, tp2)
+
         def joinOK = tp2.dealiasKeepRefiningAnnots match {
           case tp2: AppliedType if !tp2.tycon.typeSymbol.isClass =>
             // If we apply the default algorithm for `A[X] | B[Y] <: C[Z]` where `C` is a
@@ -437,25 +442,30 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             false
         }
 
+        // If LHS is a hard union, constrain any type variables of the RHS with it as lower bound
+        // before splitting the LHS into its constituents. That way, the RHS variables are
+        // constraint by the hard union and can be instantiated to it. If we just split and add
+        // the two parts of the LHS separately to the constraint, the lower bound would become
+        // a soft union.
+        def constrainRHSVars(tp2: Type): Boolean = tp2.dealiasKeepRefiningAnnots match
+          case tp2: TypeParamRef if constraint contains tp2 => compareTypeParamRef(tp2)
+          case AndType(tp21, tp22) => constrainRHSVars(tp21) && constrainRHSVars(tp22)
+          case _ => true
+
+        // An & on the left side loses information. We compensate by also trying the join.
+        // This is less ad-hoc than it looks since we produce joins in type inference,
+        // and then need to check that they are indeed supertypes of the original types
+        // under -Ycheck. Test case is i7965.scala.
         def containsAnd(tp: Type): Boolean = tp.dealiasKeepRefiningAnnots match
           case tp: AndType => true
           case OrType(tp1, tp2) => containsAnd(tp1) || containsAnd(tp2)
           case _ => false
 
-        def widenOK =
-          (tp2.widenSingletons eq tp2) &&
-          (tp1.widenSingletons ne tp1) &&
-          recur(tp1.widenSingletons, tp2)
-
         widenOK
         || joinOK
-        || recur(tp11, tp2) && recur(tp12, tp2)
+        || (tp1.isSoft || constrainRHSVars(tp2)) && recur(tp11, tp2) && recur(tp12, tp2)
         || containsAnd(tp1) && recur(tp1.join, tp2)
-            // An & on the left side loses information. Compensate by also trying the join.
-            // This is less ad-hoc than it looks since we produce joins in type inference,
-            // and then need to check that they are indeed supertypes of the original types
-            // under -Ycheck. Test case is i7965.scala.
-      case tp1: MatchType =>
+     case tp1: MatchType =>
         val reduced = tp1.reduced
         if (reduced.exists) recur(reduced, tp2) else thirdTry
       case _: FlexType =>
@@ -509,35 +519,36 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         fourthTry
     }
 
+    def compareTypeParamRef(tp2: TypeParamRef): Boolean =
+      assumedTrue(tp2) || {
+        val alwaysTrue =
+          // The following condition is carefully formulated to catch all cases
+          // where the subtype relation is true without needing to add a constraint
+          // It's tricky because we might need to either approximate tp2 by its
+          // lower bound or else widen tp1 and check that the result is a subtype of tp2.
+          // So if the constraint is not yet frozen, we do the same comparison again
+          // with a frozen constraint, which means that we get a chance to do the
+          // widening in `fourthTry` before adding to the constraint.
+          if (frozenConstraint) recur(tp1, bounds(tp2).lo)
+          else isSubTypeWhenFrozen(tp1, tp2)
+        alwaysTrue ||
+        frozenConstraint && (tp1 match {
+          case tp1: TypeParamRef => constraint.isLess(tp1, tp2)
+          case _ => false
+        }) || {
+          if (canConstrain(tp2) && !approx.low)
+            addConstraint(tp2, tp1.widenExpr, fromBelow = true)
+          else fourthTry
+        }
+      }
+
     def thirdTry: Boolean = tp2 match {
       case tp2 @ AppliedType(tycon2, args2) =>
         compareAppliedType2(tp2, tycon2, args2)
       case tp2: NamedType =>
         thirdTryNamed(tp2)
       case tp2: TypeParamRef =>
-        def compareTypeParamRef =
-          assumedTrue(tp2) || {
-            val alwaysTrue =
-              // The following condition is carefully formulated to catch all cases
-              // where the subtype relation is true without needing to add a constraint
-              // It's tricky because we might need to either approximate tp2 by its
-              // lower bound or else widen tp1 and check that the result is a subtype of tp2.
-              // So if the constraint is not yet frozen, we do the same comparison again
-              // with a frozen constraint, which means that we get a chance to do the
-              // widening in `fourthTry` before adding to the constraint.
-              if (frozenConstraint) recur(tp1, bounds(tp2).lo)
-              else isSubTypeWhenFrozen(tp1, tp2)
-            alwaysTrue ||
-            frozenConstraint && (tp1 match {
-              case tp1: TypeParamRef => constraint.isLess(tp1, tp2)
-              case _ => false
-            }) || {
-              if (canConstrain(tp2) && !approx.low)
-                addConstraint(tp2, tp1.widenExpr, fromBelow = true)
-              else fourthTry
-            }
-          }
-        compareTypeParamRef
+        compareTypeParamRef(tp2)
       case tp2: RefinedType =>
         def compareRefinedSlow: Boolean = {
           val name2 = tp2.refinedName

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

@@ -150,7 +150,14 @@ object TypeOps:
         tp.derivedAlias(simplify(tp.alias, theMap))
       case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
         simplify(l, theMap) & simplify(r, theMap)
-      case OrType(l, r) if !ctx.mode.is(Mode.Type) =>
+      case tp as OrType(l, r)
+      if !ctx.mode.is(Mode.Type)
+         && (tp.isSoft || defn.isBottomType(l) || defn.isBottomType(r)) =>
+        // Normalize A | Null and Null | A to A even if the union is hard (i.e.
+        // explicitly declared), but not if -Yexplicit-nulls is set. The reason is
+        // that in this case the normal asSeenFrom machinery is not prepared to deal
+        // with Nulls (which have no base classes). Under -Yexplicit-nulls, we take
+        // corrective steps, so no widening is wanted.
         simplify(l, theMap) | simplify(r, theMap)
       case AnnotatedType(parent, annot)
       if !ctx.mode.is(Mode.Type) && annot.symbol == defn.UncheckedVarianceAnnot =>

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

@@ -1151,10 +1151,11 @@ object Types {
       case _ => this
     }
 
-    /** Widen this type and if the result contains embedded union types, replace
+    /** Widen this type and if the result contains embedded soft union types, replace
      *  them by their joins.
-     *  "Embedded" means: inside type lambdas, intersections or recursive types, or in prefixes of refined types.
-     *  If an embedded union is found, we first try to simplify or eliminate it by
+     *  "Embedded" means: inside type lambdas, intersections or recursive types,
+     *  in prefixes of refined types, or in hard union types.
+     *  If an embedded soft union is found, we first try to simplify or eliminate it by
      *  re-lubbing it while allowing type parameters to be constrained further.
      *  Any remaining union types are replaced by their joins.
      *
@@ -1165,36 +1166,78 @@ object Types {
      *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
      *  instead of `ArrayBuffer[? >: Int | A <: Int & A]`
      *
+     *  Hard unions inside soft ones are treated specially. For illustration assume we
+     *  want to widen the type `(A | C) \/ (B | C)` where `\/` means soft union and `|`
+     *  means hard union. In that case, the hard unions `A | C` and `B | C` are treated
+     *  in an asymmetric way. Only the first parts `A` and `B` are joined and the rest
+     *  is added again with a hard union to the result. So
+     *
+     *       widenUnion[ (A | C) \/ (B | C) ]
+     *    =  widenUnion[ A \/ B ] | C | C
+     *    =  D | C | C
+     *    =  D | C
+     *
+     *  In general, If a hard union A | B_1 | ... | B_n is part of of a soft union,
+     *  only A forms part of the join, and B_1, ..., B_n are pushed out, just `C` is
+     *  pushed out above. All types that are pushed out are recombined with the result
+     *  of the join with a lub, but that lub yields again a hard union, not a soft one.
+     *
      *  Exception (if `-YexplicitNulls` is set): if this type is a nullable union (i.e. of the form `T | Null`),
      *  then the top-level union isn't widened. This is needed so that type inference can infer nullable types.
      */
-    def widenUnion(using Context): Type = widen match {
+    def widenUnion(using Context): Type = widen.match {
       case tp @ OrNull(tp1): OrType =>
         // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
         val tp1Widen = tp1.widenUnionWithoutNull
         if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
         else tp.derivedOrType(tp1Widen, defn.NullType)
       case tp =>
         tp.widenUnionWithoutNull
-    }
+    }.reporting(i"widenUnion($this) = $result")
 
-    def widenUnionWithoutNull(using Context): Type = widen match {
-      case tp @ OrType(lhs, rhs) =>
-        TypeComparer.lub(lhs.widenUnionWithoutNull, rhs.widenUnionWithoutNull, canConstrain = true) match {
-          case union: OrType => union.join
-          case res => res
-        }
-      case tp @ AndType(tp1, tp2) =>
-        tp derived_& (tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull)
-      case tp: RefinedType =>
-        tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
-      case tp: RecType =>
-        tp.rebind(tp.parent.widenUnion)
-      case tp: HKTypeLambda =>
-        tp.derivedLambdaType(resType = tp.resType.widenUnion)
-      case tp =>
-        tp
-    }
+    def widenUnionWithoutNull(using Context): Type =
+
+      // Split hard union `A | B1 | ... | Bn` into leftmost part `A` and list of
+      // pushed out parts `B1, ..., Bn`.
+      def splitAlts(tp: Type, follow: List[Type]): (Type, List[Type]) = tp match
+        case tp as OrType(lhs, rhs) if !tp.isSoft =>
+          splitAlts(lhs, rhs :: follow)
+        case _ =>
+          (tp, follow)
+
+      // Convert any soft unions in result of lub to hard ones */
+      def harden(tp: Type): Type = tp match
+        case tp as OrType(tp1, tp2) if tp.isSoft =>
+          OrType(harden(tp1), harden(tp2), soft = false)
+        case _ =>
+          tp
+
+      def recombine(tp1: Type, tp2: Type) = harden(TypeComparer.lub(tp1, tp2))
+
+      widen match
+        case tp @ OrType(lhs, rhs) =>
+          if tp.isSoft then
+            val (lhsCore, lhsExtras) = splitAlts(lhs.widenUnionWithoutNull, Nil)
+            val (rhsCore, rhsExtras) = splitAlts(rhs.widenUnionWithoutNull, Nil)
+            val core = TypeComparer.lub(lhsCore, rhsCore, canConstrain = true) match
+              case union: OrType => union.join
+              case res => res
+            rhsExtras.foldLeft(lhsExtras.foldLeft(core)(recombine))(recombine)
+          else
+            val lhs1 = lhs.widenUnionWithoutNull
+            val rhs1 = rhs.widenUnionWithoutNull
+            if (lhs1 eq lhs) && (rhs1 eq rhs) then tp else recombine(lhs1, rhs1)
+        case tp @ AndType(tp1, tp2) =>
+          tp derived_& (tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull)
+        case tp: RefinedType =>
+          tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
+        case tp: RecType =>
+          tp.rebind(tp.parent.widenUnion)
+        case tp: HKTypeLambda =>
+          tp.derivedLambdaType(resType = tp.resType.widenUnion)
+        case tp =>
+          tp
+    end widenUnionWithoutNull
 
     /** Widen all top-level singletons reachable by dealiasing
      *  and going to the operands of & and |.
@@ -3044,9 +3087,9 @@ object Types {
       myWidened
     }
 
-    def derivedOrType(tp1: Type, tp2: Type)(using Context): Type =
-      if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
-      else OrType.make(tp1, tp2, isSoft)
+    def derivedOrType(tp1: Type, tp2: Type, soft: Boolean = isSoft)(using Context): Type =
+      if ((tp1 eq this.tp1) && (tp2 eq this.tp2) && soft == isSoft) this
+      else OrType.make(tp1, tp2, soft)
 
     override def computeHash(bs: Binders): Int =
       doHash(bs, if isSoft then 0 else 1, tp1, tp2)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -214,8 +214,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       // of AndType and OrType to account for associativity
       case AndType(tp1, tp2) =>
         toTextInfixType(tpnme.raw.AMP, tp1, tp2) { toText(tpnme.raw.AMP) }
-      case OrType(tp1, tp2) =>
-        toTextInfixType(tpnme.raw.BAR, tp1, tp2) { toText(tpnme.raw.BAR) }
+      case tp as OrType(tp1, tp2) =>
+        toTextInfixType(tpnme.raw.BAR, tp1, tp2) {
+          if tp.isSoft && printDebug then toText(tpnme.ZOR) else toText(tpnme.raw.BAR)
+        }
       case tp @ EtaExpansion(tycon)
       if !printDebug && appliedText(tp.asInstanceOf[HKLambda].resType).isEmpty =>
         // don't eta contract if the application would be printed specially

tests/pos/widen-union.scala

@@ -0,0 +1,24 @@
+
+object Test1:
+  val x: Int | String = 1
+  val y = x
+  val z: Int | String = y
+
+object Test2:
+  type Sig = Int | String
+  def consistent(x: Sig, y: Sig): Boolean = ???// x == y
+
+  def consistentLists(xs: List[Sig], ys: List[Sig]): Boolean =
+       xs.corresponds(ys)(consistent)        // OK
+    || xs.corresponds(ys)(consistent(_, _))  // error, found: Any, required: Int | String
+
+object Test3:
+
+  def g[X](x: X | String): Int = ???
+  def y: Boolean | String = ???
+  g[Boolean](y)
+  g(y)
+  g[Boolean](identity(y))
+  g(identity(y))
+
+

tests/run/i8726.scala

@@ -1,5 +1,5 @@
 case class A(a: Int)
-object C { def unapply(a: A): true | true = true }
+object C { def unapply(a: A): true = true }
 
 @main
 def Test =  (A(1): A | A) match { case C() => "OK" }