Merge remote-tracking branch 'staging/UnsafeNullsSimplified' into UnsafeNulls

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -10,7 +10,7 @@ import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Decorators._, DenotTransformers._
-import Phases._, NullOpsDecorator._
+import Phases._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}

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

@@ -8,7 +8,6 @@ import Decorators._
 import collection.mutable
 import config.SourceVersion.future
 import config.Feature.sourceVersion
-import typer.Nullables
 
 /** Realizability status */
 object CheckRealizable {
@@ -149,14 +148,10 @@ class CheckRealizable(using Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
-    // In unsafe nulls, we use the old subtyping to check the bounds
-    def isSub(tp1: Type, tp2: Type): Boolean =
-      Nullables.useUnsafeNullsSubType { tp1 <:< tp2 }
-
     val memberProblems = withMode(Mode.CheckBounds) {
       for {
         mbr <- tp.nonClassTypeMembers
-        if !isSub(mbr.info.loBound, mbr.info.hiBound)
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
       yield new HasProblemBounds(mbr.name, mbr.info)
     }
@@ -166,7 +161,7 @@ class CheckRealizable(using Context) {
         name <- refinedNames(tp)
         if (name.isTypeName)
         mbr <- tp.member(name).alternatives
-        if !isSub(mbr.info.loBound, mbr.info.hiBound)
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
       yield
         new HasProblemBounds(name, mbr.info)
@@ -177,7 +172,7 @@ class CheckRealizable(using Context) {
         new HasProblemBase(base1, base2) :: Nil
       case base =>
         base.argInfos.collect {
-          case bounds @ TypeBounds(lo, hi) if !isSub(lo, hi) =>
+          case bounds @ TypeBounds(lo, hi) if !(lo <:< hi) =>
             new HasProblemBaseArg(base, bounds)
         }
     }
@@ -216,4 +211,4 @@ class CheckRealizable(using Context) {
     else
       Realizable
   }
-}
+}

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

@@ -49,15 +49,6 @@ object NullOpsDecorator:
       val stripped = self.stripNull
       stripped ne self
     }
-
-    /** Types nullable after erasure are:
-     *    - Null itself
-     *    - Any type that is a subtype of `Object`, excluding `Nothing`
-     */
-    def isNullableAfterErasure(using Context): Boolean =
-      self.isNullType
-      || !self.isNothingType
-        && self.stripNull.derivesFrom(defn.ObjectClass)
   end extension
 
   import ast.tpd._

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

@@ -797,7 +797,8 @@ object SymDenotations {
 
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(using Context): Boolean =
-      if (ctx.explicitNulls && !ctx.phase.erasedTypes) symbol == defn.NullClass || symbol == defn.AnyClass
+      if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
+      then symbol == defn.NullClass || symbol == defn.AnyClass
       else isNullableClassAfterErasure
 
     /** Is this symbol a class of which `null` is a value after erasure?
@@ -1823,12 +1824,14 @@ object SymDenotations {
       )
 
     final override def isSubClass(base: Symbol)(using Context): Boolean =
-      derivesFrom(base) ||
-        base.isClass && (
-          (symbol eq defn.NothingClass) ||
-            (!ctx.explicitNulls || ctx.phase.erasedTypes)
-            && (symbol eq defn.NullClass)
-            && (base ne defn.NothingClass))
+      derivesFrom(base)
+      || base.isClass
+         && (
+          (symbol eq defn.NothingClass)
+          || (symbol eq defn.NullClass)
+              && (!ctx.mode.is(Mode.SafeNulls) || ctx.phase.erasedTypes)
+              && (base ne defn.NothingClass)
+        )
 
     /** Is it possible that a class inherits both `this` and `that`?
      *

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

@@ -10,10 +10,8 @@ import Decorators._
 import util.Stats._
 import Names._
 import NameOps._
-import NullOpsDecorator._
 import Flags.Module
 import Variances.variancesConform
-import typer.Nullables
 import dotty.tools.dotc.config.Config
 
 object TypeApplications {
@@ -403,45 +401,41 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** 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]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false, withOrNull: Boolean = false)(using Context): Type = self match {
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
-    case OrNull(tp) =>
-      tp.translateParameterized(from, to, wildcardArg, withOrNull)
     case _ =>
       if self.derivesFrom(from) then
         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)
+            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 withOrNull && arg.isNullableAfterErasure then OrNull(arg) else arg
-        val arg2 = if (wildcardArg) TypeBounds.upper(arg1) else arg1
-        to.typeRef.appliedTo(arg2)
+        val arg1 = if (wildcardArg) TypeBounds.upper(arg) else arg
+        to.typeRef.appliedTo(arg1)
       else self
-  }
 
   /** 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 `*<?>`, and if `withOrNull` is true, the elemTp
-   *  will become nullable.
-   *  Other types are kept as-is.
+   *  will be translated to `*<?>`. Other types are kept as-is.
    */
-  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false, withOrNull: Boolean = false)(using Context): Type =
+  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false)(using Context): Type =
     val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
-    val tp = if translateWildcard && self.isInstanceOf[WildcardType] then
+    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, withOrNull = withOrNull)
+      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
     else self
-    if withOrNull then OrNull(tp) else tp
 
   /** Translate a `From[T]` into a `*T`. */
   def translateToRepeated(from: ClassSymbol)(using Context): Type =

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

@@ -485,42 +485,38 @@ object Types {
      *  instance, or NoSymbol if none exists (either because this type is not a
      *  value type, or because superclasses are ambiguous).
      */
-    final def classSymbol(using Context): Symbol = {
-      def loop(tp:Type): Symbol = tp match {
-        case tp: TypeRef =>
-          val sym = tp.symbol
-          if (sym.isClass) sym else loop(tp.superType)
-        case tp: TypeProxy =>
-          loop(tp.underlying)
-        case tp: ClassInfo =>
-          tp.cls
-        case AndType(l, r) =>
-          val lsym = loop(l)
-          val rsym = loop(r)
-          if (lsym isSubClass rsym) lsym
-          else if (rsym isSubClass lsym) rsym
-          else NoSymbol
-        case tp: OrType =>
-          if tp.tp1.hasClassSymbol(defn.NothingClass) then
-            loop(tp.tp2)
-          else if tp.tp2.hasClassSymbol(defn.NothingClass) then
-            loop(tp.tp1)
+    final def classSymbol(using Context): Symbol = this match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if (sym.isClass) sym else tp.superType.classSymbol
+      case tp: TypeProxy =>
+        tp.underlying.classSymbol
+      case tp: ClassInfo =>
+        tp.cls
+      case AndType(l, r) =>
+        val lsym = l.classSymbol
+        val rsym = r.classSymbol
+        if (lsym isSubClass rsym) lsym
+        else if (rsym isSubClass lsym) rsym
+        else NoSymbol
+      case tp: OrType =>
+        if tp.tp1.hasClassSymbol(defn.NothingClass) then
+          tp.tp2.classSymbol
+        else if tp.tp2.hasClassSymbol(defn.NothingClass) then
+          tp.tp1.classSymbol
+        else
+          def tp1Null = tp.tp1.hasClassSymbol(defn.NullClass)
+          def tp2Null = tp.tp2.hasClassSymbol(defn.NullClass)
+          if ctx.erasedTypes && (tp1Null || tp2Null) then
+            val otherSide = if tp1Null then tp.tp2.classSymbol else tp.tp1.classSymbol
+            if otherSide.isValueClass then defn.AnyClass else otherSide
           else
-            val tp1Null = tp.tp1.hasClassSymbol(defn.NullClass)
-            val tp2Null = tp.tp2.hasClassSymbol(defn.NullClass)
-            if ctx.erasedTypes && (tp1Null || tp2Null) then
-              val otherSide = if tp1Null then loop(tp.tp2) else loop(tp.tp1)
-              if otherSide.isValueClass then defn.AnyClass else otherSide
-            else
-              loop(tp.join)
-        case _: JavaArrayType =>
-          defn.ArrayClass
-        case _ =>
-          NoSymbol
-      }
+            tp.join.classSymbol
+      case _: JavaArrayType =>
+        defn.ArrayClass
+      case _ =>
+        NoSymbol
 
-      loop(this)
-    }
     /** The least (wrt <:<) set of symbols satisfying the `include` predicate of which this type is a subtype
      */
     final def parentSymbols(include: Symbol => Boolean)(using Context): List[Symbol] = this match {
@@ -1096,7 +1092,7 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      withMode(Mode.UnsafeNullsSubType)(
+      withoutMode(Mode.SafeNulls)(
         TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes))
     }
 

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -19,7 +19,6 @@ import dotty.tools.dotc.core.StdNames.{nme, tpnme}
 import dotty.tools.dotc.core.TypeComparer
 import dotty.tools.dotc.core.TypeError
 import dotty.tools.dotc.core.Types.{ExprType, MethodType, NameFilter, NamedType, NoType, PolyType, Type}
-import dotty.tools.dotc.typer.Nullables
 import dotty.tools.dotc.printing.Texts._
 import dotty.tools.dotc.util.{NameTransformer, NoSourcePosition, SourcePosition}
 
@@ -253,7 +252,7 @@ object Completion {
         }
 
       // 2. The extension method is a member of some given instance that is visible at the point of the reference.
-      val givensInScope = ctx.implicits.eligible(defn.AnyType, Nullables.unsafeNullsEnabled).map(_.implicitRef.underlyingRef)
+      val givensInScope = ctx.implicits.eligible(defn.AnyType).map(_.implicitRef.underlyingRef)
       val extMethodsFromGivensInScope = extractDefinedExtensionMethods(givensInScope)
 
       // 3. The reference is of the form r.m and the extension method is defined in the implicit scope of the type of r.

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

@@ -14,7 +14,6 @@ import Decorators._
 import Denotations._, SymDenotations._
 import TypeErasure.erasure
 import DenotTransformers._
-import NullOpsDecorator._
 
 object ElimRepeated {
   val name: String = "elimRepeated"

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

@@ -7,7 +7,6 @@ import core._
 import dotty.tools.dotc.typer.Checking
 import dotty.tools.dotc.typer.Inliner
 import dotty.tools.dotc.typer.VarianceChecker
-import dotty.tools.dotc.typer.Nullables
 import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
 import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
 import Decorators._
@@ -314,9 +313,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           args.foreach(checkInferredWellFormed)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
-            Nullables.useUnsafeNullsSubType {
-              Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
-            }
+            Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
           fn match {
             case sel: Select =>
               val args1 = transform(args)
@@ -378,9 +375,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           else if (tree.tpt.symbol == defn.orType)
             () // nothing to do
           else
-            Nullables.useUnsafeNullsSubType {
-              Checking.checkAppliedType(tree)
-            }
+            Checking.checkAppliedType(tree)
           super.transform(tree)
         case SingletonTypeTree(ref) =>
           Checking.checkRealizable(ref.tpe, ref.srcPos)
@@ -442,4 +437,4 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(using Context) =
       if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
   }
-}
+}

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

@@ -210,9 +210,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       // Second constructor of ioob that takes a String argument
       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 = head.stripNull
-          pinfo == defn.StringType
+          m.paramInfos.head.stripNull == defn.StringType
         case _ => false
       }
       val constructor = ioob.typeSymbol.info.decls.find(filterStringConstructor _).asTerm

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

@@ -13,7 +13,6 @@ import core.NameKinds.{DocArtifactName, OuterSelectName}
 import core.Decorators._
 import core.Phases._
 import core.Mode
-import core.NullOpsDecorator._
 import typer._
 import typer.ErrorReporting._
 import reporting._

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

@@ -818,6 +818,7 @@ trait Checking {
   def checkImplicitConversionUseOK(tree: Tree)(using Context): Unit =
     val tree1 = if Nullables.unsafeNullsEnabled then
       // If unsafeNulls is enabled, a cast and a closure could be added to the original tree
+      // !!! TODO: We need a test for that. Right now everything passes even if this case is commented out.
       stripCast(closureBody(tree))
     else tree
     val sym = tree1.symbol

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

@@ -161,6 +161,7 @@ object ErrorReporting {
           case fail: Implicits.NoMatchingImplicits => // do nothing
           case _ => attempts += ((failure.tree, ""))
       if foundWithoutNull then
+        // !!! TODO: The need a test that tests this error message with a check file
         i""".
           |Since explicit-nulls is enabled, the selection is rejected because
           |${qualType.widen} could be null at runtime.