Add while, match tests

Author: noti0na1

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

@@ -111,6 +111,7 @@ object Nullables with
          sym.is(Mutable)
          && sym.owner.isTerm
          && (if sym.owner != curCtx.owner then
+              // TODO: need to check by-name parameters
               !curCtx.owner.is(Flags.Lazy) // not at the rhs of lazy ValDef
               && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod // not in different DefDef
             else true)

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

@@ -352,11 +352,6 @@ class Typer extends Namer
     case ref @ OrNull(tpnn) : TermRef
     if pt != AssignProto && // Ensure it is not the lhs of Assign
     ctx.notNullInfos.impliesNotNull(ref) =>
-      // val tpeA = TypeTree(tpnn)
-      // val tpeB = TypeTree(AndType(ref, tpnn))
-      // Apply(
-      //   TypeApply(Ident(defn.Compiletime_notNull.namedType), tpeA :: tpeB :: Nil),
-      //   tree :: Nil)
       tree.select(defn.Any_typeCast).appliedToType(AndType(ref, tpnn))
     case _ =>
       tree

tests/explicit-nulls/neg/var-ref-in-closure.scala

@@ -41,7 +41,7 @@ object VarRef {
 
 
   locally {
-    var x: String|Null = "???"
+    var x: String|Null = ???
     lazy val y = {
       if (x != null) {
         val a: String = x // error: x exists in closure, no longer tackable
@@ -51,7 +51,7 @@ object VarRef {
   }
 
   locally {
-    var x: String|Null = "???"
+    var x: String|Null = ???
     def y = {
       if (x != null) {
         val a: String = x // error: x exists in closure, no longer tackable
@@ -61,7 +61,7 @@ object VarRef {
   }
 
   lazy val lazyblock = {
-    var x: String|Null = "???"
+    var x: String|Null = ???
     lazy val y = {
       if (x != null) {
         // The enclosingMethods of x definition and x reference hare are same
@@ -70,5 +70,71 @@ object VarRef {
       x
     }
   }
-}
 
+  abstract class F {
+    def get(): String | Null
+  }
+
+  locally {
+    var x: String|Null = ???
+    val y: F = new F {
+      def get() = {
+        if (x != null) x = null
+        x
+      }
+    }
+    if (x != null) {
+      val a: String = x // error: x exists in closure, no longer tackable
+    }
+  }
+
+  locally {
+    var x: String|Null = ???
+    val y: F = new F {
+      def get() = {
+        if (x != null) {
+          val a: String = x // error: x exists in closure, no longer tackable
+        }
+        x
+      }
+    }
+  }
+
+  def f(x: => String | Null): F = new F {
+    def get() = x
+  }
+
+  locally {
+    var x: String|Null = ???
+    val y: F = f {
+      if (x != null) {
+        x = null
+      }
+      x
+    }
+    if (x != null) {
+      val a: String = x // error: x exists in closure, no longer tackable
+    }
+  }
+
+  // TODO: not working now
+  // locally {
+  //   var x: String|Null = ???
+  //   val y: F = f {
+  //     if (x != null) {
+  //       val a: String = x // err: x exists in closure, no longer tackable
+  //     }
+  //     x
+  //   }
+  // }
+
+  locally {
+    var x: String|Null = ???
+    val y: String => String|Null = s => {
+      if (x != null) {
+        val a: String = x // error: x exists in closure, no longer tackable
+      }
+      x
+    }
+  }
+}

tests/explicit-nulls/pos/flow3.scala

@@ -7,9 +7,9 @@ class TreeOps {
   abstract class Tree[A, B](val key: A, val value: B)
   class RedTree[A, B](override val key: A, override val value: B) extends Tree[A, B](key, value)
 
-  private[this] inline def isRedTree(tree: Tree[_, _]) = (tree == null) && tree.isInstanceOf[RedTree[_, _]]
+  private[this] inline def isRedTree(tree: Tree[_, _] | Null) = (tree != null) && tree.isInstanceOf[RedTree[_, _]]
 
-  def foo[A, B](tree: Tree[A, B]): Unit = {
+  def foo[A, B](tree: Tree[A, B] | Null): Unit = {
     if (isRedTree(tree)) {
       val key = tree.key
       val value = tree.value

tests/explicit-nulls/pos/flow4.scala

@@ -0,0 +1,11 @@
+// Test NotNullInfo from non-null cases
+
+object MatchTest {
+  locally {
+    val s: String|Null = ???
+    s match {
+      case _: String => println(s.length)
+      case _ => println(0)
+    }
+  }
+}

tests/explicit-nulls/pos/match.scala

@@ -6,7 +6,6 @@ def f = {
     val xsx: Int = xs.x
     // Currently, we can't track a path with a mutable variable prefix,
     // even though the variable is trackable, like (xs.next != null).
-    // TODO: support this in the future?
     val xscpy: C = xs
     if (xscpy.next != null) {
       val _: Int = xscpy.next.x

tests/explicit-nulls/pos/while-loop.scala

@@ -0,0 +1,3 @@
+1
+2
+3

tests/explicit-nulls/run/while-loop.check

@@ -0,0 +1,12 @@
+
+object Test {
+  class C(val x: Int, val next: C|Null)
+
+  def main(args: Array[String]): Unit = {
+    var xs: C|Null = C(1, C(2, C(3, null)))
+    while (xs != null) {
+      println(xs.x)
+      xs = xs.next
+    }
+  }
+}