Make FlexibleType with only two fields

Author: noti0na1

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

@@ -100,8 +100,9 @@ object JavaNullInterop {
 
     /** Should we nullify `tp` at the outermost level? */
     def needsNull(tp: Type): Boolean =
-      !(outermostLevelAlreadyNullable || (tp match {
-        case tp: TypeRef =>
+      if outermostLevelAlreadyNullable then false
+      else tp match
+        case tp: TypeRef if
           // We don't modify value types because they're non-nullable even in Java.
           tp.symbol.isValueClass
           // We don't modify unit types.
@@ -113,9 +114,8 @@ object JavaNullInterop {
           // then its Scala signature will be `def setNames(names: (String|Null)*): Unit`.
           // This is because `setNames(null)` passes as argument a single-element array containing the value `null`,
           // and not a `null` array.
-          || !ctx.flexibleTypes && tp.isRef(defn.RepeatedParamClass)
-        case _ => false
-      }))
+          || !ctx.flexibleTypes && tp.isRef(defn.RepeatedParamClass) => false
+        case _ => true
 
     override def apply(tp: Type): Type = tp match {
       case tp: TypeRef if needsNull(tp) => nullify(tp)

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

@@ -9,7 +9,7 @@ object NullOpsDecorator:
 
   extension (self: Type)
     def stripFlexible(using Context): Type = self match
-      case FlexibleType(tp) => tp
+      case FlexibleType(_, tp) => tp
       case _ => self
 
     /** Syntactically strips the nullability from this type.

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

@@ -565,8 +565,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         val parent1 = recur(parent)
         if parent1 ne parent then tp.derivedCapturingType(parent1, refs) else tp
       case tp: FlexibleType =>
-        val underlying = recur(tp.underlying)
-        if underlying ne tp.underlying then tp.derivedFlexibleType(underlying) else tp
+        val hi = recur(tp.hi)
+        if hi ne tp.hi then tp.derivedFlexibleType(hi) else tp
       case tp: AnnotatedType =>
         val parent1 = recur(tp.parent)
         if parent1 ne tp.parent then tp.derivedAnnotatedType(parent1, tp.annot) else tp

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

@@ -172,7 +172,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
         // additional trait - argument-less enum cases desugar to vals.
         // See run/enum-Tree.scala.
         if tp.classSymbol.exists then tp else tp.info
-      case FlexibleType(tp) => dealiasDropNonmoduleRefs(tp)
+      case tp: FlexibleType => dealiasDropNonmoduleRefs(tp.underlying)
       case tp => tp
     }
 

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

@@ -307,7 +307,7 @@ object Types extends TypeUtils {
       isRef(defn.ObjectClass) && (typeSymbol eq defn.FromJavaObjectSymbol)
 
     def containsFromJavaObject(using Context): Boolean = this match
-      case tp: FlexibleType => tp.original.containsFromJavaObject
+      case tp: FlexibleType => tp.underlying.containsFromJavaObject
       case tp: OrType => tp.tp1.containsFromJavaObject || tp.tp2.containsFromJavaObject
       case tp: AndType => tp.tp1.containsFromJavaObject && tp.tp2.containsFromJavaObject
       case _ => isFromJavaObject
@@ -376,7 +376,7 @@ object Types extends TypeUtils {
       case AppliedType(tycon, args) => tycon.unusableForInference || args.exists(_.unusableForInference)
       case RefinedType(parent, _, rinfo) => parent.unusableForInference || rinfo.unusableForInference
       case TypeBounds(lo, hi) => lo.unusableForInference || hi.unusableForInference
-      case FlexibleType(underlying) => underlying.unusableForInference
+      case tp: FlexibleType => tp.underlying.unusableForInference
       case tp: AndOrType => tp.tp1.unusableForInference || tp.tp2.unusableForInference
       case tp: LambdaType => tp.resultType.unusableForInference || tp.paramInfos.exists(_.unusableForInference)
       case WildcardType(optBounds) => optBounds.unusableForInference
@@ -3450,49 +3450,43 @@ object Types extends TypeUtils {
 
   /* A flexible type is a type with a custom subtyping relationship.
    * It is used by explicit nulls to represent a type coming from Java which can be
-   * consider as nullable or non-nullable depending on the context, in a similar way to Platform
+   * considered as nullable or non-nullable depending on the context, in a similar way to Platform
    * Types in Kotlin. A `FlexibleType(T)` generally behaves like a type variable with special bounds
    * `T | Null .. T`, so that `T | Null <: FlexibleType(T) <: T`.
    * A flexible type will be erased to its original type `T`.
    */
-  case class FlexibleType(original: Type, lo: Type, hi: Type) extends CachedProxyType with ValueType {
-    def underlying(using Context): Type = original
+  case class FlexibleType(lo: Type, hi: Type) extends CachedProxyType with ValueType {
 
-    override def superType(using Context): Type = hi
+    override def underlying(using Context): Type = hi
 
-    def derivedFlexibleType(original: Type)(using Context): Type =
-      if this.original eq original then this else FlexibleType(original)
+    def derivedFlexibleType(hi: Type)(using Context): Type =
+      if hi eq this.hi then this else FlexibleType(hi)
 
-    override def computeHash(bs: Binders): Int = doHash(bs, original)
+    override def computeHash(bs: Binders): Int = doHash(bs, hi)
 
-    override final def baseClasses(using Context): List[ClassSymbol] = original.baseClasses
+    override final def baseClasses(using Context): List[ClassSymbol] = hi.baseClasses
   }
 
   object FlexibleType {
-    def apply(original: Type)(using Context): Type = original match {
+    def apply(tp: Type)(using Context): Type = tp match {
       case ft: FlexibleType => ft
       case _ =>
-        // val original1 = original.stripNull
-        // if original1.isNullType then
+        // val tp1 = tp.stripNull
+        // if tp1.isNullType then
         //   // (Null)? =:= ? >: Null <: (Object & Null)
-        //   FlexibleType(defn.NullType, original, AndType(defn.ObjectType, defn.NullType))
+        //   FlexibleType(tp, AndType(defn.ObjectType, defn.NullType))
         // else
         //   // (T | Null)? =:= ? >: T | Null <: T
         //   // (T)? =:= ? >: T | Null <: T
-        //   val hi = original1
-        //   val lo = if hi eq original then OrNull(hi) else original
-        //   FlexibleType(original, lo, hi)
+        //   val hi = tp1
+        //   val lo = if hi eq tp then OrNull(hi) else tp
+        //   FlexibleType(lo, hi)
         //
         // The commented out code does more work to analyze the original type to ensure the
         // flexible type is always a subtype of the original type and the Object type.
         // It is not necessary according to the use cases, so we choose to use a simpler
         // rule.
-        FlexibleType(original, OrNull(original), original)
-    }
-
-    def unapply(tp: Type)(using Context): Option[Type] = tp match {
-      case ft: FlexibleType => Some(ft.original)
-      case _ => None
+        FlexibleType(OrNull(tp), tp)
     }
   }
 
@@ -5998,7 +5992,7 @@ object Types extends TypeUtils {
       case tp: AnnotatedType =>
         samClass(tp.underlying)
       case tp: FlexibleType =>
-        samClass(tp.superType)
+        samClass(tp.underlying)
       case _ =>
         NoSymbol
 
@@ -6129,8 +6123,8 @@ object Types extends TypeUtils {
       tp.derivedJavaArrayType(elemtp)
     protected def derivedExprType(tp: ExprType, restpe: Type): Type =
       tp.derivedExprType(restpe)
-    protected def derivedFlexibleType(tp: FlexibleType, under: Type): Type =
-      tp.derivedFlexibleType(under)
+    protected def derivedFlexibleType(tp: FlexibleType, hi: Type): Type =
+      tp.derivedFlexibleType(hi)
     // note: currying needed  because Scala2 does not support param-dependencies
     protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type =
       tp.derivedLambdaType(tp.paramNames, formals, restpe)
@@ -6255,7 +6249,7 @@ object Types extends TypeUtils {
           derivedOrType(tp, this(tp.tp1), this(tp.tp2))
 
         case tp: FlexibleType =>
-          derivedFlexibleType(tp, this(tp.underlying))
+          derivedFlexibleType(tp, this(tp.hi))
 
         case tp: MatchType =>
           val bound1 = this(tp.bound)
@@ -6544,14 +6538,17 @@ object Types extends TypeUtils {
           if (underlying.isExactlyNothing) underlying
           else tp.derivedAnnotatedType(underlying, annot)
       }
-    override protected def derivedFlexibleType(tp: FlexibleType, underlying: Type): Type =
-      underlying match {
+
+    override protected def derivedFlexibleType(tp: FlexibleType, hi: Type): Type =
+      hi match {
         case Range(lo, hi) =>
-          range(tp.derivedFlexibleType(lo), tp.derivedFlexibleType(hi))
+          // We know FlexibleType(t).hi = t and FlexibleType(t).lo = OrNull(t)
+          range(OrNull(lo), hi)
         case _ =>
-          if (underlying.isExactlyNothing) underlying
-          else tp.derivedFlexibleType(underlying)
+          if (hi.isExactlyNothing) hi
+          else tp.derivedFlexibleType(hi)
       }
+
     override protected def derivedCapturingType(tp: Type, parent: Type, refs: CaptureSet): Type =
       parent match // TODO ^^^ handle ranges in capture sets as well
         case Range(lo, hi) =>

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

@@ -294,7 +294,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
             && !printDebug
         then atPrec(GlobalPrec)( Str("into ") ~ toText(tpe) )
         else toTextLocal(tpe) ~ " " ~ toText(annot)
-      case FlexibleType(tpe) =>
+      case FlexibleType(_, tpe) =>
         "(" ~ toText(tpe) ~ ")?"
       case tp: TypeVar =>
         def toTextCaret(tp: Type) = if printDebug then toTextLocal(tp) ~ Str("^") else toText(tp)

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

@@ -152,7 +152,7 @@ object TypeTestsCasts {
             // See TypeComparer#either
             recur(tp1, P) && recur(tp2, P)
           case tpX: FlexibleType =>
-            recur(tpX.original, P)
+            recur(tpX.underlying, P)
           case x =>
             // always false test warnings are emitted elsewhere
             // provablyDisjoint wants fully applied types as input; because we're in the middle of erasure, we sometimes get raw types here