Fix bounds realizability check and vargs

Author: noti0na1

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

@@ -7,7 +7,8 @@ import Denotations.SingleDenotation
 import Decorators._
 import collection.mutable
 import config.SourceVersion.`3.1`
-import config.Feature.sourceVersion
+import config.Feature.{sourceVersion, unsafeNullsEnabled}
+import typer.Nullables
 
 /** Realizability status */
 object CheckRealizable {
@@ -160,10 +161,14 @@ class CheckRealizable(using Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
+    val unsafeNullsSub = unsafeNullsEnabled
+    def isSub(tp1: Type, tp2: Type): Boolean =
+      Nullables.useUnsafeNullsSubTypeIf(unsafeNullsSub)(tp1 <:< tp2)
+
     val memberProblems = withMode(Mode.CheckBounds) {
       for {
         mbr <- tp.nonClassTypeMembers
-        if !(mbr.info.loBound <:< mbr.info.hiBound)
+        if !isSub(mbr.info.loBound, mbr.info.hiBound)
       }
       yield new HasProblemBounds(mbr.name, mbr.info)
     }
@@ -173,7 +178,7 @@ class CheckRealizable(using Context) {
         name <- refinedNames(tp)
         if (name.isTypeName)
         mbr <- tp.member(name).alternatives
-        if !(mbr.info.loBound <:< mbr.info.hiBound)
+        if !isSub(mbr.info.loBound, mbr.info.hiBound)
       }
       yield
         new HasProblemBounds(name, mbr.info)
@@ -184,7 +189,7 @@ class CheckRealizable(using Context) {
         new HasProblemBase(base1, base2) :: Nil
       case base =>
         base.argInfos.collect {
-          case bounds @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+          case bounds @ TypeBounds(lo, hi) if !isSub(lo, hi) =>
             new HasProblemBaseArg(base, bounds)
         }
     }

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

@@ -1,10 +1,12 @@
-package dotty.tools.dotc.core
+package dotty.tools.dotc
+package core
 
-import Contexts.{Context, ctx}
+import ast.Trees._
+import Contexts._
 import Symbols.defn
 import Types._
 
-/** Defines operations on nullable types. */
+/** Defines operations on nullable types and tree. */
 object NullOpsDecorator {
 
   extension (self: Type) {
@@ -76,4 +78,13 @@ object NullOpsDecorator {
       || !self.isNothingType
         && self.derivesFrom(defn.ObjectClass, isErased = true)
   }
+
+  import ast.tpd._
+
+  extension (self: Tree) {
+    def castToNonNullable(using Context): Tree = self.typeOpt match {
+      case OrNull(tp) => self.cast(tp)
+      case _ => self
+    }
+  }
 }

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

@@ -10,9 +10,11 @@ import Decorators._
 import util.Stats._
 import Names._
 import NameOps._
+import NullOpsDecorator._
 import Flags.Module
 import Variances.variancesConform
 import dotty.tools.dotc.config.Config
+import config.Feature.unsafeNullsEnabled
 
 object TypeApplications {
 
@@ -400,21 +402,26 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  `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]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match {
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false, withOrNull: Boolean = false)(using Context): Type = self match {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
-      if (self.derivesFrom(from)) {
+      if (self.derivesFrom(from, isErased = unsafeNullsEnabled || withOrNull)) {
+        def isBottom(t: Type): Boolean =
+          if unsafeNullsEnabled || withOrNull
+          then t.isBottomTypeAfterErasure
+          else t.isBottomType
         def elemType(tp: Type): Type = tp.widenDealias match
           case tp: OrType =>
-            if tp.tp1.isBottomType then elemType(tp.tp2)
-            else if tp.tp2.isBottomType then elemType(tp.tp1)
+            if isBottom(tp.tp1) then elemType(tp.tp2)
+            else if isBottom(tp.tp2) then elemType(tp.tp1)
             else tp.derivedOrType(elemType(tp.tp1), elemType(tp.tp2))
           case tp: AndType => tp.derivedAndType(elemType(tp.tp1), elemType(tp.tp2))
           case _ => tp.baseType(from).argInfos.headOption.getOrElse(defn.NothingType)
         val arg = elemType(self)
-        val arg1 = if (wildcardArg) TypeBounds.upper(arg) else arg
-        to.typeRef.appliedTo(arg1)
+        val arg1 = if withOrNull && arg.isNullableAfterErasure then OrNull(arg) else arg
+        val arg2 = if (wildcardArg) TypeBounds.upper(arg1) else arg1
+        to.typeRef.appliedTo(arg2)
       }
       else self
   }
@@ -425,14 +432,14 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  will be translated to `*<?>`.
    *  Other types are kept as-is.
    */
-  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false)(using Context): Type =
+  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false, withOrNull: Boolean = false)(using Context): Type =
     val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
     if translateWildcard && self.isInstanceOf[WildcardType] then
       seqClass.typeRef.appliedTo(WildcardType)
     else if self.isRepeatedParam then
       // We want `Array[? <: T]` because arrays aren't covariant until after
       // erasure. See `tests/pos/i5140`.
-      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
+      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray, withOrNull = withOrNull)
     else self
 
   /** Translate a `From[T]` into a `*T`. */

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

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