Update comments

Author: noti0na1

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

@@ -117,26 +117,14 @@ class CheckRealizable(using Context) {
     case _: SingletonType | NoPrefix =>
       Realizable
     case tp =>
-      // TODO
-      // check the realizability of a special AndType
-      def checkAndType(x: TermRef, y: Type) =
-        (realizability(x) eq Realizable) && (y <:< x.widen)
-      val isRealizableAndType = tp match {
-        case AndType(tr: TermRef, tp1) =>
-          checkAndType(tr, tp1)
-        case AndType(tp1, tr: TermRef) =>
-          checkAndType(tr, tp1)
-        case _ => false
-      }
       def isConcrete(tp: Type): Boolean = tp.dealias match {
         case tp: TypeRef => tp.symbol.isClass
         case tp: TypeProxy => isConcrete(tp.underlying)
         case tp: AndType => isConcrete(tp.tp1) && isConcrete(tp.tp2)
         case tp: OrType  => isConcrete(tp.tp1) && isConcrete(tp.tp2)
         case _ => false
       }
-      if isRealizableAndType then Realizable
-      else if !isConcrete(tp) then NotConcrete
+      if (!isConcrete(tp)) NotConcrete
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
@@ -161,6 +149,7 @@ class CheckRealizable(using Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
+    // In unsafe nulls, we use the old subtyping to check the bounds
     val unsafeNullsSub = unsafeNullsEnabled
     def isSub(tp1: Type, tp2: Type): Boolean =
       Nullables.useUnsafeNullsSubTypeIf(unsafeNullsSub)(tp1 <:< tp2)

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

@@ -614,7 +614,7 @@ class Definitions {
     @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 || (if ctx.explicitNulls then pt.stripNull else pt).isAnyRef
+        pt.isAny || pt.stripNull.isAnyRef
       case _ => false
     }).symbol
 
@@ -626,15 +626,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) =>
-        val pt1 = if ctx.explicitNulls then pt.stripNull else pt
-        pt1.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) =>
-        val pt1 = if ctx.explicitNulls then pt.stripNull else pt
-        pt1.isRef(StringClass)
+        pt.stripNull.isRef(StringClass)
       case _ => false
     }).symbol.asTerm
 

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

@@ -15,6 +15,7 @@ object NullOpsDecorator {
      *  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 strip(tp: Type): Type =
@@ -41,17 +42,7 @@ object NullOpsDecorator {
         }
         if tpStriped ne tpWiden then tpStriped else tp
 
-      strip(self)
-    }
-
-    def stripAllNulls(using Context): Type = {
-      object RemoveNulls extends TypeMap {
-        override def apply(tp: Type): Type =
-          val mapped = mapOver(tp.widenTermRefExpr.stripNull)
-          if tp eq mapped then tp else mapped
-      }
-      val rem = RemoveNulls(self)
-      if rem ne self then rem else self
+      if ctx.explicitNulls then strip(self) else self
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
@@ -60,19 +51,7 @@ object NullOpsDecorator {
       stripped ne self
     }
 
-    /** Can the type has null value after erasure?
-     *  TODO
-     */
-    // def isNullableAfterErasure(using Context): Boolean =  self match {
-    //   case tp: ClassInfo => tp.cls.isNullableClassAfterErasure
-    //   case tp: TypeProxy => tp.underlying.isNullableAfterErasure
-    //   case OrType(lhs, rhs) =>
-    //     lhs.isNullableAfterErasure || rhs.isNullableAfterErasure
-    //   case AndType(lhs, rhs) =>
-    //     lhs.isNullableAfterErasure && rhs.isNullableAfterErasure
-    //   case _ =>
-    //     self.isNullType || self <:< defn.ObjectType
-    // }
+    /** If a type is nullable after erasure */
     def isNullableAfterErasure(using Context): Boolean =
       self.isNullType
       || !self.isNothingType
@@ -82,6 +61,7 @@ object NullOpsDecorator {
   import ast.tpd._
 
   extension (self: Tree) {
+    // cast the type of the tree to a non-nullable type
     def castToNonNullable(using Context): Tree = self.typeOpt match {
       case OrNull(tp) => self.cast(tp)
       case _ => self

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

@@ -398,7 +398,9 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
   }
 
-  /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set). Keep other types as they are.
+  /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set).
+   *  Ff `withOrNull` is true, the elemTp will become nullable.
+   *  Keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]
    */
@@ -429,7 +431,8 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** If this is a repeated parameter `*T`, translate it to either `Seq[T]` or
    *  `Array[? <: T]` depending on the value of `toArray`.
    *  Additionally, if `translateWildcard` is true, a wildcard type
-   *  will be translated to `*<?>`.
+   *  will be translated to `*<?>`, and if `withOrNull` is true, the elemTp
+   *  will become nullable.
    *  Other types are kept as-is.
    */
   def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false, withOrNull: Boolean = false)(using Context): Type =

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

@@ -172,11 +172,10 @@ object Types {
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.parent.isStable
       case tp: AndType =>
-        // if one side is stable and another side is realizable or a subtype,
-        // then the AndType is stable
-        def checkAndStable(x: Type, y: Type) =
-          x.isStable && ((realizability(y) eq Realizable) || y <:< x.widen)
-        checkAndStable(tp.tp1, tp.tp2) || checkAndStable(tp.tp2, tp.tp1)
+        // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing
+        // see: tests/explicit-nulls/pos/flow-stable.scala.disabled
+        tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
+        tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
       case _ => false
     }
 
@@ -1047,6 +1046,7 @@ object Types {
      *  member `sym2` of type `that`? This is the same as `<:<`, except that
      *  @param matchLoosely   if true the types `=> T` and `()T` are seen as overriding each other.
      *  @param checkClassInfo if true we check that ClassInfos are within bounds of abstract types
+     *  @param relaxedNulls   if true the null type is ignored during subtype check.
      */
     final def overrides(that: Type, matchLoosely: => Boolean,
       checkClassInfo: Boolean = true, relaxedNulls: Boolean = false)(using Context): Boolean = {
@@ -3178,10 +3178,8 @@ object Types {
     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] =
-      if ctx.explicitNulls then
-        val tp1 = tp.stripNull
-        if tp1 ne tp then Some(tp1) else None
-      else None
+      val tp1 = tp.stripNull
+      if tp1 ne tp then Some(tp1) else None
   }
 
   // ----- ExprType and LambdaTypes -----------------------------------

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

@@ -155,8 +155,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
     case SeqLiteral(elems, elemtpt) =>
       JavaSeqLiteral(elems, elemtpt)
     case _ =>
-      // TODO remove Null from the type first
-      val elemType = tree.tpe.stripNull.elemType
+      val elemType = tree.tpe.elemType
       var elemClass = erasure(elemType).classSymbol
       if defn.NotRuntimeClasses.contains(elemClass) then
         elemClass = defn.ObjectClass
@@ -173,8 +172,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
    *        of generic Java varargs in `elimRepeated`.
    */
   private def adaptToArray(tree: Tree, elemPt: Type)(implicit ctx: Context): Tree =
-    // TODO remove Null from the type first
-    val elemTp = tree.tpe.stripNull.elemType
+    val elemTp = tree.tpe.elemType
     val elemTpMatches = elemTp <:< elemPt
     val treeIsArray = tree.tpe.derivesFrom(defn.ArrayClass)
     if elemTpMatches && treeIsArray then

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

@@ -46,8 +46,7 @@ class ExpandSAMs extends MiniPhase {
           checkRefinements(tpe, fn)
           tree
         case tpe =>
-          val tpe0 = if ctx.explicitNulls then tpe.stripNull else tpe
-          val tpe1 = checkRefinements(tpe0, fn)
+          val tpe1 = checkRefinements(tpe.stripNull, fn)
           val Seq(samDenot) = tpe1.possibleSamMethods
           cpy.Block(tree)(stats,
               AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.asTerm.name :: Nil))

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

@@ -211,7 +211,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       def filterStringConstructor(s: Symbol): Boolean = s.info match {
         case m: MethodType if s.isConstructor && m.paramInfos.size == 1 =>
           val head = m.paramInfos.head
-          val pinfo = if ctx.explicitNulls then head.stripNull else head
+          val pinfo = head.stripNull
           pinfo == defn.StringType
         case _ => false
       }

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

@@ -22,22 +22,34 @@ object Nullables:
 
   private def needNullifyHi(lo: Type, hi: Type)(using Context): Boolean =
     ctx.explicitNulls
-    && lo.isExactlyNull
+    && lo.isExactlyNull // only nullify hi if lo is exactly Null type
     && hi.isValueType
+    // We cannot check if hi is nullable, because it can cause cyclic reference.
 
+  /** Create a nullable type bound
+   *  If the lo is `Null`, `| Null` is added to hi
+   */
   def createNullableTypeBounds(lo: Type, hi: Type)(using Context): TypeBounds =
     val newHi = if needNullifyHi(lo, hi) then OrType(hi, defn.NullType, soft = false) else hi
     TypeBounds(lo, newHi)
 
+
+  /** Create a nullable type bound tree
+   *  If the lo is `Null`, `| Null` is added to hi
+   */
   def createNullableTypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(using Context): TypeBoundsTree =
     val hiTpe = hi.typeOpt
     val newHi = if needNullifyHi(lo.typeOpt, hiTpe) then TypeTree(OrType(hiTpe, defn.NullType, soft = false)) else hi
     TypeBoundsTree(lo, newHi, alias)
 
+  /** Use unsafe nulls subtyping where `Null` is a subtype of all reference types */
   inline def useUnsafeNullsSubTypeIf[T](cond: Boolean)(inline op: Context ?=> T)(using Context): T =
     val c = if cond then ctx.addMode(Mode.UnsafeNullsSubType) else ctx
     op(using c)
 
+  /** A StickyKey for TypeApply and AppliedType in unsafe nulls,
+   *  In PostTyper, a relaxed bound check is used for these types.
+   */
   val UnsafeNullsKey = Property.StickyKey[Boolean]
 
   /** A set of val or var references that are known to be not null, plus a set of