Remove asymmetric option in code and comments

Author: odersky

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

@@ -1166,22 +1166,6 @@ 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.
      */
@@ -1214,30 +1198,13 @@ object Types {
 
       def recombine(tp1: Type, tp2: Type) = harden(TypeComparer.lub(tp1, tp2))
 
-      inline val asymmetric = false
-
       widen match
-        case tp @ OrType(lhs, rhs) =>
-          if asymmetric then
-            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)
-          else if tp.isSoft then
-            TypeComparer.lub(lhs.widenUnionWithoutNull, rhs.widenUnionWithoutNull, canConstrain = true) match
-              case union: OrType => union.join
-              case res => res
-          else
-            tp.derivedOrType(lhs.widenUnionWithoutNull, rhs.widenUnionWithoutNull)
-        case tp @ AndType(tp1, tp2) =>
-          tp derived_& (tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull)
+        case tp @ OrType(lhs, rhs) if tp.isSoft =>
+          TypeComparer.lub(lhs.widenUnionWithoutNull, rhs.widenUnionWithoutNull, canConstrain = true) match
+            case union: OrType => union.join
+            case res => res
+        case tp: AndOrType =>
+          tp.derivedAndOrType(tp.tp1.widenUnionWithoutNull, tp.tp2.widenUnionWithoutNull)
         case tp: RefinedType =>
           tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
         case tp: RecType =>