Fix widenUnion with flexible types

Author: noti0na1

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

@@ -696,9 +696,11 @@ trait ConstraintHandling {
       tp.rebind(tp.parent.hardenUnions)
     case tp: HKTypeLambda =>
       tp.derivedLambdaType(resType = tp.resType.hardenUnions)
+    case tp: FlexibleType =>
+      tp.derivedFlexibleType(tp.hi.hardenUnions)
     case tp: OrType =>
-      val tp1 = tp.stripNull
-      if tp1 ne tp then tp.derivedOrType(tp1.hardenUnions, defn.NullType)
+      val tp1 = tp.stripNull(stripFlexibleTypes = false)
+      if tp1 ne tp then tp.derivedOrType(tp1.hardenUnions, defn.NullType, soft = false)
       else tp.derivedOrType(tp.tp1.hardenUnions, tp.tp2.hardenUnions, soft = false)
     case _ =>
       tp

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

@@ -648,7 +648,7 @@ class Definitions {
   @tu lazy val StringModule: Symbol = StringClass.linkedClass
     @tu lazy val String_+ : TermSymbol = enterMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
     @tu lazy val String_valueOf_Object: Symbol = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
-      case List(pt) => pt.isAny || pt.stripNull.isAnyRef
+      case List(pt) => pt.isAny || pt.stripNull().isAnyRef
       case _ => false
     }).symbol
 
@@ -660,13 +660,13 @@ class Definitions {
   @tu lazy val ClassCastExceptionClass: ClassSymbol   = requiredClass("java.lang.ClassCastException")
     @tu lazy val ClassCastExceptionClass_stringConstructor: TermSymbol  = ClassCastExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        pt.stripNull.isRef(StringClass)
+        pt.stripNull().isRef(StringClass)
       case _ => false
     }).symbol.asTerm
   @tu lazy val ArithmeticExceptionClass: ClassSymbol  = requiredClass("java.lang.ArithmeticException")
     @tu lazy val ArithmeticExceptionClass_stringConstructor: TermSymbol  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        pt.stripNull.isRef(StringClass)
+        pt.stripNull().isRef(StringClass)
       case _ => false
     }).symbol.asTerm
 

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

@@ -8,17 +8,13 @@ import Types.*
 object NullOpsDecorator:
 
   extension (self: Type)
-    def stripFlexible(using Context): Type = self match
-      case FlexibleType(_, tp) => tp
-      case _ => self
-
     /** Syntactically strips the nullability from this type.
      *  If the type is `T1 | ... | Tn`, and `Ti` references to `Null`,
      *  then return `T1 | ... | Ti-1 | Ti+1 | ... | Tn`.
      *  If this type isn't (syntactically) nullable, then returns the type unchanged.
      *  The type will not be changed if explicit-nulls is not enabled.
      */
-    def stripNull(using Context): Type = {
+    def stripNull(stripFlexibleTypes: Boolean = true)(using Context): Type = {
       def strip(tp: Type): Type =
         val tpWiden = tp.widenDealias
         val tpStripped = tpWiden match {
@@ -37,7 +33,9 @@ object NullOpsDecorator:
             if (tp1s ne tp1) && (tp2s ne tp2) then
               tp.derivedAndType(tp1s, tp2s)
             else tp
-          case tp: FlexibleType => tp.hi
+          case tp: FlexibleType =>
+            val hi1 = strip(tp.hi)
+            if stripFlexibleTypes then hi1 else tp.derivedFlexibleType(hi1)
           case tp @ TypeBounds(lo, hi) =>
             tp.derivedTypeBounds(strip(lo), strip(hi))
           case tp => tp
@@ -49,7 +47,7 @@ object NullOpsDecorator:
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
     def isNullableUnion(using Context): Boolean = {
-      val stripped = self.stripNull
+      val stripped = self.stripNull()
       stripped ne self
     }
   end extension

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

@@ -24,7 +24,6 @@ import reporting.trace
 import annotation.constructorOnly
 import cc.*
 import NameKinds.WildcardParamName
-import NullOpsDecorator.stripFlexible
 
 /** Provides methods to compare types.
  */

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

@@ -928,7 +928,7 @@ object Types extends TypeUtils {
             // Selecting `name` from a type `T | Null` is like selecting `name` from `T`, if
             // unsafeNulls is enabled and T is a subtype of AnyRef.
             // This can throw at runtime, but we trade soundness for usability.
-            tp1.findMember(name, pre.stripNull, required, excluded)
+            tp1.findMember(name, pre.stripNull(), required, excluded)
           case _ =>
             searchAfterJoin
         else searchAfterJoin
@@ -1352,13 +1352,13 @@ object Types extends TypeUtils {
      *  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
-      case tp: OrType => tp match
-        case OrNull(tp1) =>
-          // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
+      case tp: OrType =>
+        val tp1 = tp.stripNull(stripFlexibleTypes = false)
+        if tp1 ne tp then
           val tp1Widen = tp1.widenUnionWithoutNull
-          if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
+          if tp1Widen.isRef(defn.AnyClass) then tp1Widen
           else tp.derivedOrType(tp1Widen, defn.NullType)
-        case _ =>
+        else
           tp.widenUnionWithoutNull
       case tp =>
         tp.widenUnionWithoutNull
@@ -1373,6 +1373,8 @@ object Types extends TypeUtils {
         tp.rebind(tp.parent.widenUnion)
       case tp: HKTypeLambda =>
         tp.derivedLambdaType(resType = tp.resType.widenUnion)
+      case tp: FlexibleType =>
+        tp.derivedFlexibleType(tp.hi.widenUnionWithoutNull)
       case tp =>
         tp
 
@@ -3476,7 +3478,7 @@ object Types extends TypeUtils {
     def apply(tp: Type)(using Context): Type = tp match {
       case ft: FlexibleType => ft
       case _ =>
-        // val tp1 = tp.stripNull
+        // val tp1 = tp.stripNull()
         // if tp1.isNullType then
         //   // (Null)? =:= ? >: Null <: (Object & Null)
         //   FlexibleType(tp, AndType(defn.ObjectType, defn.NullType))
@@ -3749,7 +3751,8 @@ object Types extends TypeUtils {
       assert(!ctx.isAfterTyper, s"$tp in $where") // we check correct kinds at PostTyper
       throw TypeError(em"$tp is not a value type, cannot be used $where")
 
-  /** An extractor object to pattern match against a nullable union.
+  /** An extractor object to pattern match against a nullable union
+   *  (including flexible types).
    *  e.g.
    *
    *  (tp: Type) match
@@ -3760,7 +3763,7 @@ object Types extends TypeUtils {
     def apply(tp: Type)(using Context) =
       if tp.isNullType then tp else OrType(tp, defn.NullType, soft = false)
     def unapply(tp: Type)(using Context): Option[Type] =
-      val tp1 = tp.stripNull
+      val tp1 = tp.stripNull()
       if tp1 ne tp then Some(tp1) else None
   }
 

compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala

@@ -293,7 +293,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
     val element = array.elemType.hiBound // T
 
     if element <:< defn.AnyRefType
-      || ctx.mode.is(Mode.SafeNulls) && element.stripNull <:< defn.AnyRefType
+      || ctx.mode.is(Mode.SafeNulls) && element.stripNull() <:< defn.AnyRefType
       || element.typeSymbol.isPrimitiveValueClass
     then array
     else defn.ArrayOf(TypeBounds.upper(AndType(element, defn.AnyRefType))) // Array[? <: T & AnyRef]

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -427,7 +427,7 @@ abstract class Recheck extends Phase, SymTransformer:
       TypeComparer.lub(bodyType :: casesTypes)
 
     def recheckSeqLiteral(tree: SeqLiteral, pt: Type)(using Context): Type =
-      val elemProto = pt.stripNull.elemType match
+      val elemProto = pt.stripNull().elemType match
         case NoType => WildcardType
         case bounds: TypeBounds => WildcardType(bounds)
         case elemtp => elemtp

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -252,7 +252,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       // Second constructor of ioob that takes a String argument
       def filterStringConstructor(s: Symbol): Boolean = s.info match {
         case m: MethodType if s.isConstructor && m.paramInfos.size == 1 =>
-          m.paramInfos.head.stripNull == defn.StringType
+          m.paramInfos.head.stripNull() == defn.StringType
         case _ => false
       }
       val constructor = ioob.typeSymbol.info.decls.find(filterStringConstructor _).asTerm

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

@@ -971,7 +971,7 @@ trait Applications extends Compatibility {
             // one can imagine the original signature-polymorphic method as
             // being infinitely overloaded, with each individual overload only
             // being brought into existence as needed
-            val originalResultType = funRef.symbol.info.resultType.stripNull
+            val originalResultType = funRef.symbol.info.resultType.stripNull()
             val resultType =
               if !originalResultType.isRef(defn.ObjectClass) then originalResultType
               else AvoidWildcardsMap()(proto.resultType.deepenProtoTrans) match

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

@@ -1085,7 +1085,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      * with annotation contructor, as named arguments are not allowed anywhere else in Java.
      * Under explicit nulls, the pt could be nullable. We need to strip `Null` type first.
      */
-    val arg1 = pt.stripNull match {
+    val arg1 = pt.stripNull() match {
       case AppliedType(a, typ :: Nil) if ctx.isJava && a.isRef(defn.ArrayClass) =>
         tryAlternatively { typed(tree.arg, pt) } {
             val elemTp = untpd.TypedSplice(TypeTree(typ))
@@ -1914,7 +1914,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val case1 = typedCase(cas, sel, wideSelType, tpe)(using caseCtx)
         caseCtx = Nullables.afterPatternContext(sel, case1.pat)
         if !alreadyStripped && Nullables.matchesNull(case1) then
-          wideSelType = wideSelType.stripNull
+          wideSelType = wideSelType.stripNull()
           alreadyStripped = true
         case1
       }
@@ -1937,7 +1937,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val case1 = typedCase(cas, sel, wideSelType, pt)(using caseCtx)
       caseCtx = Nullables.afterPatternContext(sel, case1.pat)
       if !alreadyStripped && Nullables.matchesNull(case1) then
-        wideSelType = wideSelType.stripNull
+        wideSelType = wideSelType.stripNull()
         alreadyStripped = true
       case1
     }
@@ -2140,7 +2140,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     else res
 
   def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral = {
-    val elemProto = pt.stripNull.elemType match {
+    val elemProto = pt.stripNull().elemType match {
       case NoType => WildcardType
       case bounds: TypeBounds => WildcardType(bounds)
       case elemtp => elemtp

tests/explicit-nulls/pos/widen-nullable-union.scala

@@ -39,4 +39,16 @@ class Test {
     val y = x
     val _: (A & B) | Null = y
   }
+
+  def test1(s: String): String =
+    val ss = if !s.isEmpty() then s.trim() else s
+    ss + "!"
+
+  def test2(s: String): String =
+    val ss = if !s.isEmpty() then s.trim().nn else s
+    ss + "!"
+
+  def test3(s: String): String =
+    val ss: String = if !s.isEmpty() then s.trim().nn else s
+    ss + "!"
 }