add tests and clean code

Author: noti0na1

compiler/src/dotty/tools/dotc/Run.scala

@@ -7,15 +7,13 @@ import Periods._
 import Symbols._
 import Types._
 import Scopes._
-import StdNames.nme
 import Names.Name
 import Denotations.Denotation
 import typer.Typer
 import typer.ImportInfo._
 import Decorators._
 import io.{AbstractFile, PlainFile, VirtualFile}
 import Phases.unfusedPhases
-import config.Feature
 
 import util._
 import reporting.Reporter

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

@@ -10,12 +10,10 @@ import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Decorators._, DenotTransformers._
-import Phases._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
 import typer.ConstFold
-import typer.Nullables
 
 import scala.annotation.tailrec
 import scala.io.Codec
@@ -471,7 +469,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** The wrapped array method name for an array of type elemtp */
   def wrapArrayMethodName(elemtp: Type)(using Context): TermName = {
-    val elemCls = atPhase(erasurePhase.next) { elemtp.classSymbol }
+    val elemCls = elemtp.classSymbol
     if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
     else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray

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

@@ -211,4 +211,4 @@ class CheckRealizable(using Context) {
     else
       Realizable
   }
-}
+}

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

@@ -20,7 +20,6 @@ import Nullables._
 import Implicits.ContextualImplicits
 import config.Settings._
 import config.Config
-import config.Feature
 import reporting._
 import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
 import scala.io.Codec
@@ -29,6 +28,7 @@ import printing._
 import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
 import classfile.ReusableDataReader
 import StdNames.nme
+
 import scala.annotation.internal.sharable
 
 import DenotTransformers.DenotTransformer

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

@@ -1218,7 +1218,8 @@ class Definitions {
     idx == name.length || name(idx).isDigit && digitsOnlyAfter(name, idx + 1)
 
   def isBottomClass(cls: Symbol): Boolean =
-    if ctx.explicitNulls && !ctx.phase.erasedTypes then cls == NothingClass
+    if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
+    then cls == NothingClass
     else isBottomClassAfterErasure(cls)
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass

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

@@ -127,10 +127,4 @@ object Mode {
    *  This mode forces expansion of inline calls in those positions even during typing.
    */
   val ForceInline: Mode = newMode(29, "ForceInline")
-
-  /** Should we use Unsafe Nulls SubTyping in TypeComparer?
-   *  If this mode is in the Context, `Null` is considered as a
-   *  subtype of all reference type.
-   */
-  val UnsafeNullsSubType: Mode = newMode(30, "UnsafeNullsSubType")
 }

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

@@ -761,11 +761,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             isSubType(hi1, tp2, approx.addLow) || compareGADT || tryLiftedToThis1
           case _ =>
             def isNullable(tp: Type): Boolean = tp.widenDealias match {
-              case tp: TypeRef =>
-                if ctx.explicitNulls && ctx.mode.is(Mode.UnsafeNullsSubType) then
-                  tp.symbol.isNullableClassAfterErasure
-                else
-                  tp.symbol.isNullableClass
+              case tp: TypeRef => tp.symbol.isNullableClass
               case tp: RefinedOrRecType => isNullable(tp.parent)
               case tp: AppliedType => isNullable(tp.tycon)
               case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)

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

@@ -816,21 +816,16 @@ trait Checking {
    *  enabled.
    */
   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
+    val sym = tree.symbol
     if sym.name == nme.apply
        && sym.owner.derivesFrom(defn.ConversionClass)
        && !sym.info.isErroneous
     then
-      def conv = methPart(tree1) match
+      def conv = methPart(tree) match
         case Select(qual, _) => qual.symbol.orElse(sym.owner)
         case _ => sym.owner
       checkFeature(nme.implicitConversions,
-        i"Use of implicit conversion ${conv.showLocated}", NoSymbol, tree1.srcPos)
+        i"Use of implicit conversion ${conv.showLocated}", NoSymbol, tree.srcPos)
 
   private def infixOKSinceFollowedBy(tree: untpd.Tree): Boolean = tree match {
     case _: untpd.Block | _: untpd.Match => true

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

@@ -161,7 +161,6 @@ 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.

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

@@ -797,11 +797,9 @@ class Typer extends Namer
         // A sequence argument `xs: _*` can be either a `Seq[T]` or an `Array[_ <: T]`,
         // irrespective of whether the method we're calling is a Java or Scala method,
         // so the expected type is the union `Seq[T] | Array[_ <: T]`.
-        // If unsafe nulls is enabled, the expected type is `Seq[T | Null] | Array[_ <: T | Null] | Null`.
-        val unsafeNulls = Nullables.unsafeNullsEnabled
         val ptArg =
           // FIXME(#8680): Quoted patterns do not support Array repeated arguments
-          if (ctx.mode.is(Mode.QuotedPattern))
+          if ctx.mode.is(Mode.QuotedPattern) then
             pt.translateFromRepeated(toArray = false, translateWildcard = true)
           else
             pt.translateFromRepeated(toArray = false, translateWildcard = true)
@@ -815,7 +813,7 @@ class Typer extends Namer
               // We need to make sure its type is no longer nullable
               expr0.castToNonNullable
           else expr0
-        val fromCls = if expr1.tpe.stripNull.derivesFrom(defn.ArrayClass)
+        val fromCls = if expr1.tpe.derivesFrom(defn.ArrayClass)
           then defn.ArrayClass else defn.SeqClass
         val tpt1 = TypeTree(expr1.tpe.widen.translateToRepeated(fromCls)).withSpan(tree.tpt.span)
         assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
@@ -3866,4 +3864,4 @@ class Typer extends Namer
           EmptyTree
     else typedExpr(call, defn.AnyType)
 
-}
+}

tests/explicit-nulls/neg/array.scala

@@ -0,0 +1,44 @@
+// Test array with nulls.
+
+class ArrayWithNulls {
+  def test1 = {
+    // A non-nullable array of non-nullable strings
+    val a1: Array[String] = Array("hello")
+    val s1: String = a1(0)
+    val s2: String | Null = a1(0)
+    val a2: Array[String] = Array()
+
+    // Array type is non-nullable
+    val b1: Array[String] = null // error
+    val b2: Array[Int] = null // error
+  }
+
+  def test2 = {
+    // A nullable array of non-nullable strings
+    val a1: Array[String] | Null = null
+    val a2: Array[String] | Null = Array()
+    val a3: Array[String] | Null = Array("")
+    val a4: Array[String] | Null = Array("", null) // error
+
+    // A non-nullable array of nullable strings
+    val b1: Array[String | Null] = Array()
+    val b2: Array[String | Null] = Array(null)
+    val b3: Array[String | Null] = Array("")
+    val b4: Array[String | Null] = Array("", null)
+    val b5: Array[String | Null] = null // error
+
+    val s1: String = b1(0) // error
+    val s2: String | Null = b1(0)
+
+    // A nullable array of nullable strings
+    val c1: Array[String | Null] | Null = Array()
+  }
+
+  def test3 = {
+    val a1: Array[String] = Array()
+
+    val a2: Array[String] | Null = a1
+
+    val a3: Array[String | Null] = a1 // error
+  }
+}

tests/explicit-nulls/neg/basic.scala

@@ -1,18 +1,33 @@
 // Test that reference types are no longer nullable.
 
-class Foo {
-  val s: String = null // error
-  val s1: String | Null = null
-  val s2: String | Null = ""
+class Basic {
+  val no: Nothing = ???
 
-  val b: Boolean = null // error
-  val c: Int | Null = null
+  val n: Null = null
+  val n2: Null = no
+
+  val any1: Any  = null
+  val any2: Any  = n
+
+  val s1: String = null // error
+  val s2: String = n // error
+  val s3: String | Null = null
+  val s4: String | Null = n
+  val s5: String | Null = ""
 
   val ar1: AnyRef = null // error
-  val ar2: AnyRef | Null = null
-  val ob: Object = null // error
+  val ar2: AnyRef = n // error
+  val ar3: AnyRef | Null = null
+  val ob1: Object = null // error
+  val ob2: Object | Null = null
+
+  val b1: Boolean = null // error
+  val b2: Boolean = n // error
+  val b3: Boolean | Null = null
+
+  val c1: Int = null // error
+  val c2: Int = n // error
+  val i3: Int | Null = null
 
   val av: AnyVal = null // error
-  val a: Any  = null
-  val n: Null = null
 }

tests/explicit-nulls/neg/bounds.scala

@@ -1,22 +1,30 @@
-val x1: String = ???
-val x2: String | Null = ???
+// Test Null type in bounds
 
-// T has to be nullable type
-def f1[T >: Null <: AnyRef | Null](x: T): T = x
+class Test {
+  val x1: String = ???
+  val x2: String | Null = ???
 
-// 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
+  // T has to be nullable type
+  def f1[T >: Null <: AnyRef | Null](x: T): T = x
 
-def nullOf[T >: Null <: AnyRef | Null]: T = null
+  // Null is no longer a subtype of AnyRef, so it is impossible to apply this method directly.
+  // However, defining this kind of functions is allowed.
+  // We can bypass this restriction by importing unsafeNulls.
+  def f2[T >: Null <: AnyRef](x: T): T = x
 
-def g = {
-  f1(x1)
-  f1(x2)
+  def nullOf[T >: Null <: AnyRef | Null]: T = null
 
-  f2(x1) // error
-  f2(x2) // error
+  def g = {
+    f1(x1)
+    f1(x2)
 
-  val n1: String = nullOf // error
-  val n3: String | Null = nullOf
+    f2(x1) // error
+    f2(x2) // error
+
+    val n1: String = nullOf // error
+    val n3: String | Null = nullOf
+  }
+
+  // Bounds in class definition is strictly checked
+  class A[T >: Null <: AnyRef] {} // error: conflicting bounds Null <: ... <: AnyRef
 }

tests/explicit-nulls/neg/default.scala

@@ -1,11 +1,17 @@
 class Foo {
-  val x: String = null // error: String is non-nullable
+  val s: String = null // error: String is non-nullable
 
   def foo(x: String): String = "x"
 
-  val y = foo(null) // error: String argument is non-nullable
+  val fn = foo(null) // error: String argument is non-nullable
 
-  val z: String = foo("hello")
+  val x: String = foo("hello")
+
+  val arr: Array[Int] = null // error: Array is non-nullable
+
+  val t: (String, Int) = null // error: Tuple is non-nullable
+
+  val f: String => Int = null // error: Function is non-nullable
 
   class Bar
   val b: Bar = null // error: user-created classes are also non-nullable

tests/explicit-nulls/neg/nn-basic.check

@@ -0,0 +1,16 @@
+-- [E008] Not Found Error: tests/explicit-nulls/neg/nn-basic.scala:3:21 ------------------------------------------------
+3 |  val s2: String = s.trim // error
+  |                   ^^^^^^
+  |                   value trim is not a member of String | Null.
+  |                   Since explicit-nulls is enabled, the selection is rejected because
+  |                   String | Null could be null at runtime.
+  |                   If you want to select trim without checking for a null value,
+  |                   insert a .nn before .trim or import scala.language.unsafeNulls.
+-- [E008] Not Found Error: tests/explicit-nulls/neg/nn-basic.scala:5:17 ------------------------------------------------
+5 |  val l: Int = s.length // error
+  |               ^^^^^^^^
+  |               value length is not a member of String | Null.
+  |               Since explicit-nulls is enabled, the selection is rejected because
+  |               String | Null could be null at runtime.
+  |               If you want to select length without checking for a null value,
+  |               insert a .nn before .length or import scala.language.unsafeNulls.

tests/explicit-nulls/neg/nn-basic.scala

@@ -0,0 +1,6 @@
+class Test {
+  val s: String | Null = ???
+  val s2: String = s.trim // error
+  val s3: String | Null = s.nn.trim
+  val l: Int = s.length // error
+}

tests/explicit-nulls/neg/nn.scala

@@ -2,9 +2,17 @@
 
 class Test {
   val s1: String | Null = ???
-  val s2: String = s1.nn
+  val s2: String = s1 // error
+  val s3: String = s1.nn
+
+  val l1: Int = s1.length // error
+  val l2: Int = s1.nn.length
 
   val ss1: Array[String | Null] | Null = ???
   val ss2: Array[String | Null] = ss1.nn
   val ss3: Array[String] = ss1.nn // error
+  val ss4: Array[String] = ss1.asInstanceOf
+
+  val a1: String | Null = ss1(0) // error
+  val a2: String | Null = ss1.nn(0)
 }