Add additional explicit nulls tests

Author: abeln

tests/explicit-nulls/neg/alias.scala

@@ -0,0 +1,24 @@
+
+// Test that nullability is correctly detected
+// in the presence of a type alias.
+class Base {
+  type T >: Null <: AnyRef|Null
+}
+
+object foo {
+  class Foo {
+    val length: Int = 42
+    def doFoo(): Unit = ()
+  }
+}
+
+class Derived extends Base {
+  type Nullable[X] = X|Null
+  type Foo = Nullable[foo.Foo]
+
+  def fun(foo: Foo): Unit = {
+    foo.length  // error: foo is nullable
+    foo.doFoo() // error: foo is nullable
+  }
+}
+

tests/explicit-nulls/neg/default.scala

@@ -0,0 +1,13 @@
+
+class Foo {
+  val x: String = null // error: String is non-nullable
+
+  def foo(x: String): String = "x"
+
+  val y = foo(null) // error: String argument is non-nullable
+
+  val z: String = foo("hello")
+
+  class Bar
+  val b: Bar = null // error: user-created classes are also non-nullable
+}

tests/explicit-nulls/neg/eq.scala

@@ -0,0 +1,26 @@
+// Test what can be compared for equality against null.
+class Foo {
+  // Null itself
+  val x0: Null = null
+  x0 == null
+  null == x0
+  null == null
+
+  // Nullable types: OK
+  val x1: String|Null = null
+  x1 == null
+  null == x1
+
+  // Reference types, even non-nullable ones: OK.
+  // Allowed as an escape hatch.
+  val x2: String = "hello"
+  x2 != null 
+  x2 == null
+  null == x2
+
+  // Value types: not allowed.
+  1 == null    // error
+  null == 1    // error
+  true == null // error
+  null == true // error
+}

tests/explicit-nulls/neg/eq2.scala

@@ -0,0 +1,15 @@
+
+// Test that we can't compare for equality `null` and
+// classes that derive from AnyVal.
+class Foo(x: Int) extends AnyVal
+
+class Bar {
+  val foo: Foo = new Foo(15)
+  if (foo == null) {} // error
+  if (null == foo) {} // error
+
+  // To test against null, make the type nullable.
+  val foo2: Foo|Null = foo
+  if (foo2 == null) {} 
+  if (null == foo2) {}
+}

tests/explicit-nulls/neg/strip.scala

@@ -0,0 +1,16 @@
+
+class Foo {
+
+  class B1
+  class B2
+
+  val x: (Null | String) | Null |  (B1 | (Null | B2)) = ???
+  if (x != null) {
+    val x2: String | B1 | B2 = x // ok: can remove all nullable unions
+  }
+
+  val x2: (Null | String) & (Null | B1) = ???
+  if (x2 != null) {
+    val x3: String & B1 = x2 // error: can't remove null from embedded intersection
+  }
+}

tests/explicit-nulls/neg/type-arg.scala

@@ -0,0 +1,13 @@
+
+// Test that reference types being non-nullable
+// is checked when lower bound of a type argument
+// is Null.
+object Test {
+  type Untyped = Null
+  class TreeInstances[T >: Untyped]
+  class Type
+  
+  object untpd extends TreeInstances[Null]
+  // There are two errors reported for the line below (don't know why).
+  object tpd extends TreeInstances[Type] // error // error
+}

tests/explicit-nulls/pos/nn2.scala

@@ -0,0 +1,10 @@
+
+// Test that is fixed when explicit nulls are enabled.
+// https://github.com/lampepfl/dotty/issues/6247
+
+class Foo {
+  val x1: String|Null = null
+  x1.nn.length
+  val x2: String = x1.nn
+  x1.nn.length
+}