Modify upper bounds from tasty and class

Author: noti0na1

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

@@ -116,9 +116,11 @@ 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 isStableAndType = tp match {
+      val isRealizableAndType = tp match {
         case AndType(tr: TermRef, tp1) =>
           checkAndType(tr, tp1)
         case AndType(tp1, tr: TermRef) =>
@@ -132,7 +134,7 @@ class CheckRealizable(using Context) {
         case tp: OrType  => isConcrete(tp.tp1) && isConcrete(tp.tp2)
         case _ => false
       }
-      if isStableAndType then Realizable
+      if isRealizableAndType then Realizable
       else if !isConcrete(tp) then NotConcrete
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }

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

@@ -648,11 +648,6 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         tpnme.WILDCARD
       case tp: WildcardType =>
         sigName(tp.optBounds)
-      case OrNull(tp) =>
-        // If explicit nulls is enabled and the type is nullable union,
-        // we need to strip nulls before computing the signiture name.
-        // For example, the correct name of `String | Null` is `String` instead of `Object`.
-        sigName(tp)
       case _ =>
         val erasedTp = this(tp)
         assert(erasedTp ne tp, tp)

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

@@ -170,6 +170,8 @@ 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)
@@ -3125,7 +3127,7 @@ object Types {
    */
   object OrNull {
     def apply(tp: Type)(using Context) =
-      OrType(tp, defn.NullType, soft = false)
+      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

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -29,6 +29,7 @@ import util.SourceFile
 import ast.{TreeTypeMap, Trees, tpd, untpd}
 import Trees._
 import Decorators._
+import NullOpsDecorator._
 import transform.SymUtils._
 
 import dotty.tools.tasty.{TastyBuffer, TastyReader}
@@ -362,7 +363,12 @@ class TreeUnpickler(reader: TastyReader,
               if nothingButMods(end) then
                 if lo.isMatch then MatchAlias(readVariances(lo))
                 else TypeAlias(readVariances(lo))
-              else TypeBounds(lo, readVariances(readType()))
+              else
+                val hi0 = readVariances(readType())
+                val hi =
+                  if ctx.explicitNulls && lo.isNullType && hi0.isNullableAfterErasure
+                  then OrNull(hi0) else hi0
+                TypeBounds(lo, hi)
             case ANNOTATEDtype =>
               AnnotatedType(readType(), Annotation(readTerm()))
             case ANDtype =>
@@ -1239,7 +1245,10 @@ class TreeUnpickler(reader: TastyReader,
               MatchTypeTree(bound, scrut, readCases(end))
             case TYPEBOUNDStpt =>
               val lo = readTpt()
-              val hi = if currentAddr == end then lo else readTpt()
+              val hi0 = if currentAddr == end then lo else readTpt()
+              val hi =
+                if ctx.explicitNulls && lo.tpe.isNullType && hi0.tpe.isNullableAfterErasure
+                then TypeTree(OrNull(hi0.tpe)) else hi0
               val alias = if currentAddr == end then EmptyTree else readTpt()
               TypeBoundsTree(lo, hi, alias)
             case HOLE =>
@@ -1478,4 +1487,4 @@ object TreeUnpickler {
   final val AllDefs = 2          // add everything
 
   class TreeWithoutOwner extends Exception
-}
+}

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -23,6 +23,7 @@ import PickleBuffer._
 import PickleFormat._
 import Decorators._
 import TypeApplications._
+import NullOpsDecorator._
 import classfile.ClassfileParser
 import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
@@ -769,7 +770,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         else if (sym.typeParams.nonEmpty) tycon.EtaExpand(sym.typeParams)
         else tycon
       case TYPEBOUNDStpe =>
-        TypeBounds(readTypeRef(), readTypeRef())
+        val lo = readTypeRef()
+        val hi0 = readTypeRef()
+        val hi =
+          if ctx.explicitNulls && lo.isNullType && hi0.isNullableAfterErasure
+          then OrNull(hi0) else hi0
+        TypeBounds(lo, hi)
       case REFINEDtpe =>
         val clazz = readSymbolRef().asClass
         val decls = symScope(clazz)
@@ -1247,7 +1253,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
       case TYPEBOUNDStree =>
         val lo = readTreeRef()
-        val hi = readTreeRef()
+        val hi0 = readTreeRef()
+        val hi =
+          if ctx.explicitNulls && lo.tpe.isNullType && hi0.tpe.isNullableAfterErasure
+          then TypeTree(OrNull(hi0.tpe)) else hi0
         TypeBoundsTree(lo, hi)
 
       case EXISTENTIALTYPEtree =>
@@ -1309,4 +1318,4 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       case other =>
         errorBadSignature("expected an TypeDef (" + other + ")")
     }
-}
+}

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

@@ -334,7 +334,7 @@ object Implicits:
     }
 
     /** The implicit references that are eligible for type `tp`. */
-    def eligible(tp: Type, enableUnsafeNulls: Boolean = false): List[Candidate] =
+    def eligible(tp: Type, enableUnsafeNulls: Boolean): List[Candidate] =
       if tp.hash == NotCached then
         Stats.record(i"compute eligible not cached ${tp.getClass}")
         Stats.record(i"compute eligible not cached")

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

@@ -157,7 +157,7 @@ trait ImportSuggestions:
     // are in the implicit scope of `pt`.
     val alreadyAvailableCandidates: Set[Symbol] = {
       val wildProto = wildApprox(pt)
-      val contextualCandidates = ctx.implicits.eligible(wildProto)
+      val contextualCandidates = ctx.implicits.eligible(wildProto, ctx.mode.is(Mode.UnsafeNullConversion))
       val implicitScopeCandidates = ctx.run.implicitScope(wildProto).eligible
       val allCandidates = contextualCandidates ++ implicitScopeCandidates
       allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet

tests/explicit-nulls/neg/bounds.scala

@@ -0,0 +1,22 @@
+val x1: String = ???
+val x2: String | Null = ???
+
+// T has to be nullable type
+def f1[T >: Null <: AnyRef | Null](x: T): T = x
+
+// Null is no longer a subtype of AnyRef, impossible to apply this method directly.
+// We can bypass this restriction by importing unsafeNulls.
+def f2[T >: Null <: AnyRef](x: T): T = x
+
+def nullOf[T >: Null <: AnyRef | Null]: T = null
+
+def g = {
+  f1(x1)
+  f1(x2)
+
+  f2(x1) // error
+  f2(x2) // error
+
+  val n1: String = nullOf // error
+  val n3: String | Null = nullOf
+}