Update hi nullification rule

Author: noti0na1

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

@@ -24,12 +24,12 @@ import Variances.Invariant
 import TastyUnpickler.NameTable
 import typer.ConstFold
 import typer.Checking.checkNonCyclic
+import typer.Nullables._
 import util.Spans._
 import util.SourceFile
 import ast.{TreeTypeMap, Trees, tpd, untpd}
 import Trees._
 import Decorators._
-import NullOpsDecorator._
 import transform.SymUtils._
 
 import dotty.tools.tasty.{TastyBuffer, TastyReader}
@@ -364,11 +364,8 @@ class TreeUnpickler(reader: TastyReader,
                 if lo.isMatch then MatchAlias(readVariances(lo))
                 else TypeAlias(readVariances(lo))
               else
-                val hi0 = readVariances(readType())
-                val hi =
-                  if ctx.explicitNulls && lo.isBottomTypeAfterErasure && hi0.isNullableAfterErasure
-                  then OrNull(hi0) else hi0
-                TypeBounds(lo, hi)
+                val hi = readVariances(readType())
+                createNullableTypeBounds(lo, hi)
             case ANNOTATEDtype =>
               AnnotatedType(readType(), Annotation(readTerm()))
             case ANDtype =>
@@ -1249,12 +1246,9 @@ class TreeUnpickler(reader: TastyReader,
               MatchTypeTree(bound, scrut, readCases(end))
             case TYPEBOUNDStpt =>
               val lo = readTpt()
-              val hi0 = if currentAddr == end then lo else readTpt()
-              val hi =
-                if ctx.explicitNulls && lo.tpe.isBottomTypeAfterErasure && hi0.tpe.isNullableAfterErasure
-                then TypeTree(OrNull(hi0.tpe)) else hi0
+              val hi = if currentAddr == end then lo else readTpt()
               val alias = if currentAddr == end then EmptyTree else readTpt()
-              TypeBoundsTree(lo, hi, alias)
+              createNullableTypeBoundsTree(lo, hi, alias)
             case HOLE =>
               val idx = readNat()
               val tpe = readType()

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

@@ -18,12 +18,12 @@ import printing.Printer
 import io.AbstractFile
 import util.common._
 import typer.Checking.checkNonCyclic
+import typer.Nullables._
 import transform.SymUtils._
 import PickleBuffer._
 import PickleFormat._
 import Decorators._
 import TypeApplications._
-import NullOpsDecorator._
 import classfile.ClassfileParser
 import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
@@ -772,11 +772,8 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         else tycon
       case TYPEBOUNDStpe =>
         val lo = readTypeRef()
-        val hi0 = readTypeRef()
-        val hi =
-          if ctx.explicitNulls && lo.isBottomTypeAfterErasure && hi0.isNullableAfterErasure
-          then OrNull(hi0) else hi0
-        TypeBounds(lo, hi)
+        val hi = readTypeRef()
+        createNullableTypeBounds(lo, hi)
       case REFINEDtpe =>
         val clazz = readSymbolRef().asClass
         val decls = symScope(clazz)
@@ -1254,11 +1251,8 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
       case TYPEBOUNDStree =>
         val lo = readTreeRef()
-        val hi0 = readTreeRef()
-        val hi =
-          if ctx.explicitNulls && lo.tpe.isBottomTypeAfterErasure && hi0.tpe.isNullableAfterErasure
-          then TypeTree(OrNull(hi0.tpe)) else hi0
-        TypeBoundsTree(lo, hi)
+        val hi = readTreeRef()
+        createNullableTypeBoundsTree(lo, hi)
 
       case EXISTENTIALTYPEtree =>
         val tpt = readTreeRef()

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

@@ -20,7 +20,28 @@ import ast.Trees.mods
 object Nullables:
   import ast.tpd._
 
-  inline def useUnsafeNullsSubTypeIf[T](cond: Boolean)(inline op: Context ?=> T)(using Context): T = 
+  private def needNullifyHi(lo: Type, hi: Type)(using Context): Boolean =
+    ctx.explicitNulls
+    && lo.isBottomTypeAfterErasure
+    && !hi.isAny
+    && !hi.isBottomTypeAfterErasure
+    && hi.isValueType
+    && hi.isNullableAfterErasure
+
+  def createNullableTypeBounds(lo: Type, hi: Type)(using Context): TypeBounds =
+    TypeBounds(lo,
+      if needNullifyHi(lo, hi)
+      then OrNull(hi)
+      else hi)
+
+  def createNullableTypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(using Context): TypeBoundsTree =
+    val hiTpe = hi.typeOpt
+    TypeBoundsTree(lo,
+      if needNullifyHi(lo.typeOpt, hiTpe)
+      then TypeTree(OrNull(hiTpe))
+      else hi, alias)
+
+  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)
 

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

@@ -3554,7 +3554,7 @@ class Typer extends Namer
         }
       }
 
-      val treeTpe = tree.tpe
+      val treeTpe = tree.typeOpt
 
       def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
         if pt.isValueType
@@ -3579,14 +3579,15 @@ class Typer extends Namer
         else ctx
 
       inContext(searchCtx) {
-        if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
-          if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
-            // We want to allow `null` to `AnyRef` if UnsafeNullConversion is enabled
-            if !(useUnsafeNullsSubTypeIf(ctx.mode.is(Mode.UnsafeNullConversion))(
-              treeTpe <:< pt)) then
-              report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
+        if ctx.mode.is(Mode.ImplicitsEnabled) && treeTpe.isValueType then
+          if ctx.mode.is(Mode.UnsafeNullConversion)
+            && pt.isValueType
+            && (treeTpe.isNullableAfterErasure && pt.isRef(defn.ObjectClass)
+              || treeTpe.isNullType && pt.isNullableAfterErasure) then
             tree.cast(pt)
           else
+            if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
+              report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
             searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
         else tryUnsafeNullConver(recover(NoMatchingImplicits))
       }

tests/explicit-nulls/unsafe-common/unsafe-eq.scala

@@ -1,5 +1,5 @@
 val s1: String = ???
-val s2: String  | Null = ???
+val s2: String | Null = ???
 
 def f = {
   s1 eq s2 // error