add tests

Author: noti0na1

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

tests/explicit-nulls/neg-separate/upper-bounds/TestA_1.scala

@@ -0,0 +1,8 @@
+class A[T >: Null <: AnyRef] {
+  def f[S >: Null <: T](x: S): Unit = ()
+}
+
+object B {
+  def f[T >: Null <: AnyRef](x: T): Unit = ()
+  def nullOf[T >: Null <: AnyRef]: T = null
+}

tests/explicit-nulls/neg-separate/upper-bounds/TestB_2.scala

@@ -0,0 +1,18 @@
+def test1 = {
+  val a1: A[AnyRef] = ??? // error
+  val a2: A[AnyRef | Null] = ???
+  val a3: A[String | Null] = ???
+
+  a2.f[String]("") // error
+  a2.f[String | Null]("")
+  a2.f[String | Null](null)
+}
+
+def test2 = {
+  val x1: String = ???
+  val x2: String | Null = ???
+
+  B.f(x1)
+  B.f[String](x1) // error
+  B.f[String | Null](x1)
+}

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/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.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)
 }

tests/explicit-nulls/neg/nullable-types.scala

@@ -0,0 +1,50 @@
+class Varargs {
+  val xs1: Seq[String] = ???
+  val xs2: Seq[String | Null] = ???
+  val xs3: Seq[String | Null] | Null = ???
+  val xs4: Seq[String] | Null = ???
+
+  val ys1: Array[String] = ???
+  val ys2: Array[String | Null] = ???
+  val ys3: Array[String | Null] | Null = ???
+  val ys4: Array[String] | Null = ???
+
+  def f1(xs: String*): Unit = ???
+  def f2(xs: (String | Null)*): Unit = ???
+
+  def test = {
+    f1()
+    f1(null) // error
+    f1("")
+    f1("", null) // error
+    f1(null: _*) // error
+
+    f1(xs1: _*)
+    f1(xs2: _*) // error
+    f1(xs3: _*) // error
+    f1(xs4: _*) // error
+
+    f1(ys1: _*)
+    f1(ys2: _*) // error
+    f1(ys3: _*) // error
+    f1(ys4: _*) // error
+  }
+
+  def test2 = {
+    f2()
+    f2(null)
+    f2("")
+    f2("", null)
+    f2(null: _*) // error
+
+    f2(xs1: _*)
+    f2(xs2: _*)
+    f2(xs3: _*) // error
+    f2(xs4: _*) // error
+
+    f2(ys1: _*)
+    f2(ys2: _*)
+    f2(ys3: _*) // error
+    f2(ys4: _*) // error
+  }
+}

tests/explicit-nulls/neg/varargs.scala

@@ -2,4 +2,24 @@
 class Foo {
   val x: Array[String] = Array("hello")
   val s: String = x(0)
+
+  def test = {
+    // accept any array of string
+    def f(xs: Array[_ >: String <: String | Null] | Null): Unit = ???
+
+    val a1: Array[String] = ???
+    val a2: Array[String] | Null = ???
+    val a3: Array[String | Null] = ???
+    val a4: Array[String | Null] | Null = ???
+
+    f(null)
+    f(Array())
+    f(Array(null))
+    f(Array(""))
+    f(Array("", null))
+    f(a1)
+    f(a2)
+    f(a3)
+    f(a4)
+  }
 }

tests/explicit-nulls/pos/array.scala

@@ -0,0 +1,15 @@
+class Test {
+  def f(g: String => String): Unit = ???
+
+  def g1(x: String): String = ???
+  def g2(x: String | Null): String = ???
+  def g3(x: String): String | Null = ???
+  def g4(x: String | Null): String | Null = ???
+
+  def test = {
+    f(g1) // ok
+    f(g2) // ok: (String | Null => String) <:< (String => String)
+    f(g3) // error
+    f(g4) // error
+  }
+}