add flow 'tests

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

@@ -352,15 +352,15 @@ class Typer extends Namer
  case ref @ OrNull(tpnn) : TermRef
  if pt != AssignProto && // Ensure it is not the lhs of Assign
  ctx.notNullInfos.impliesNotNull(ref) =>
- // def $notNull[A, B](x: A | Null): B = x.asInstanceOf
- // For a TermRef x: T|Null,
- // if x is inmutable: $notNull[T, x.type & T](x),
- // if x is mutable: $notNull[T, T](x).
  val tpeA = TypeTree(tpnn)
- val tpeB = if (ref.symbol.is(Mutable)) tpeA else TypeTree(AndType(ref, tpnn))
- Apply(
- TypeApply(Ident(defn.Compiletime_notNull.namedType), tpeA :: tpeB :: Nil),
- tree :: Nil)
+ val tpeB = TypeTree(AndType(ref, tpnn))
+ //val tpeB = if (ref.symbol.is(Mutable)) tpeA else TypeTree(AndType(ref, tpnn))
+ val newTree = TypeApply(Select(tree, defn.Any_typeCast.namedType), tpeB :: Nil)
+ //newTree.symbol.setFlag(Erased)
+ // val newTree = Apply(
+ // TypeApply(Ident(defn.Compiletime_notNull.namedType), tpeA :: tpeB :: Nil),
+ // tree :: Nil)
+ newTree
  case _ =>
  tree
 

tests/explicit-nulls/neg/flow-conservative.scala

@@ -0,0 +1,55 @@
+
+// Show that the static analysis behind flow typing is conservative.
+
+class Test {
+
+ val x: String|Null = ???
+
+ // Why is the then branch ok, but the else problematic?
+ // The problem is that we're computing a "must not be null analysis".
+ // So we know that
+ // 1) if the condition x == null && x != null, then both sides of the
+ // and must be true. Then it must be the case that x != null, so we 
+ // know that x cannot be null and x.length is allowed.
+ // Of course, the then branch will never execute, but the analysis doesn't
+ // know (so it's ok to say that x won't be null).
+ // 2) if the condition is false, then we only know that _one_ or more
+ // of the operands failed, but we don't know _which_.
+ // This means that we can only pick the flow facts that hold for _both_
+ // operands. In particular, we look at x == null, and see that if the condition
+ // is false, then x must _not_ be null. But then we look at what happens if
+ // x != null is false, and we can't conclude that any variables must be non-null.
+ // When we intersect the two sets {x} and \empty, we get the empty set, which
+ // correctly approximates reality, which is that we can get to the else branch
+ // regardless of whether x is null.
+
+ if (x == null && x != null) {
+ val y = x.length // ok
+ } else {
+ val y = x.length // error
+ }
+
+ // Next we show how strengthening the condition can backfire in an
+ // unintuitive way.
+ if (x != null && 1 == 1) {
+ val y = x.length // ok
+ }
+
+ if (x == null) {
+ } else {
+ val y = x.length // ok
+ }
+
+ // But
+ if (x == null && 1 == 1) { // logically equivalent to `x == null`, but the 
+ // analysis doesn't known
+ } else {
+ val y = x.length // error
+ }
+
+ // The problem here is the same. If the condition is false
+ // then we know the l.h.s implies that x must not be null.
+ // But the r.h.s doesn't tell us anything about x, so we can't
+ // assume that x is non-null. Then the fact that x is non-null can't
+ // be propagated to the else branch.
+}

tests/explicit-nulls/neg/flow-implicitly.scala

@@ -0,0 +1,10 @@
+
+// Test that flow typing works well with implicit resolution.
+class Test {
+ implicit val x: String | Null = ???
+ implicitly[x.type <:< String] // error: x.type is widened String|Null
+
+ if (x != null) {
+ implicitly[x.type <:< String] // ok: x.type is widened to String
+ }
+}

tests/explicit-nulls/neg/flow.scala

@@ -0,0 +1,182 @@
+
+// Flow-sensitive type inference
+class Foo {
+
+ def basic() = {
+ class Bar {
+ val s: String = ???
+ }
+
+ // Basic
+ val b: Bar|Null = ???
+ if (b != null) {
+ val s = b.s // ok: type of `b` inferred as `Bar`
+ val s2: Bar = b
+ } else {
+ val s = b.s // error: `b` is `Bar|Null`
+ }
+ val s = b.s // error: `b` is `Bar|Null`
+ }
+
+ def notStable() = {
+ class Bar {
+ var s: String = ???
+ }
+
+ var b2: Bar|Null = ???
+ if (b2 != null) {
+ val s = b2.s
+ }
+ }
+
+ def nested() = {
+ class Bar2 {
+ val x: Bar2|Null = ???
+ }
+
+ val bar2: Bar2|Null = ???
+ if (bar2 != null) {
+ if (bar2.x != null) {
+ if (bar2.x.x != null) {
+ if (bar2.x.x.x != null) {
+ val b2: Bar2 = bar2.x.x.x
+ }
+ val b2: Bar2 = bar2.x.x
+ val b2err: Bar2 = bar2.x.x.x // error: expected Bar2 but got Bar2|Null
+ }
+ val b2: Bar2 = bar2.x
+ }
+ val b2: Bar2 = bar2
+ }
+ }
+
+ def ifThenElse() = {
+ val s: String|Null = ???
+ if (s == null) {
+ } else {
+ val len: Int = s.length
+ val len2 = s.length
+ }
+ }
+
+ def elseIf() = {
+ val s1: String|Null = ???
+ val s2: String|Null = ???
+ val s3: String|Null = ???
+ if (s1 != null) {
+ val len = s1.length
+ val err1 = s2.length // error
+ val err2 = s3.length // error
+ } else if (s2 != null) {
+ val len = s2.length
+ val err1 = s1.length // error
+ val err2 = s3.length // error
+ } else if (s3 != null) {
+ val len = s3.length
+ val err1 = s1.length // error
+ val err2 = s2.length // error
+ }
+
+ // Accumulation in elseif
+ if (s1 == null) {
+ } else if (s2 == null) {
+ val len = s1.length
+ } else if (s3 == null) {
+ val len1 = s1.length
+ val len2 = s2.length
+ } else {
+ val len1 = s1.length
+ val len2 = s2.length
+ val len3 = s3.length
+ }
+ }
+
+ def commonIdioms() = {
+ val s1: String|Null = ???
+ val s2: String|Null = ???
+ val s3: String|Null = ???
+
+ if (s1 == null || s2 == null || s3 == null) {
+ } else {
+ val len1: Int = s1.length
+ val len2: Int = s2.length
+ val len3: Int = s3.length
+ }
+
+ if (s1 != null && s2 != null && s3 != null) {
+ val len1: Int = s1.length
+ val len2: Int = s2.length
+ val len3: Int = s3.length
+ }
+ }
+
+ def basicNegation() = {
+ val s1: String|Null = ???
+ if (!(s1 != null)) {
+ val len = s1.length // error
+ } else {
+ val len = s1.length
+ }
+
+ if (!(!(!(!(s1 != null))))) {
+ val len1 = s1.length
+ }
+ }
+
+ def parens() = {
+ val s1: String|Null = ???
+ val s2: String|Null = ???
+ if ((((s1 == null))) || s2 == null) {
+ } else {
+ val len1 = s1.length
+ val len2 = s2.length
+ }
+ }
+
+ def operatorPrec() = {
+ val s1: String|Null = ???
+ val s2: String|Null = ???
+ val s3: String|Null = ???
+
+ if (s1 != null || s2 != null && s3 != null) {
+ val len = s3.length // error
+ }
+
+ if (s1 != null && s2 != null || s3 != null) {
+ val len1 = s1.length // error
+ val len2 = s2.length // error
+ val len3 = s3.length // error
+ }
+
+ if (s1 != null && (s2 != null || s3 != null)) {
+ val len1 = s1.length
+ val len2 = s2.length // error
+ val len3 = s3.length // error
+ }
+ }
+
+ def insideCond() = {
+ val x: String|Null = ???
+ if (x != null && x.length > 0) {
+ val len = x.length
+ } else {
+ val len = x.length // error
+ }
+
+ if (x == null || x.length > 0) {
+ val len = x.length // error
+ } else {
+ val len = x.length
+ }
+
+ class Rec {
+ val r: Rec|Null = ???
+ }
+
+ val r: Rec|Null = ???
+ if (r != null && r.r != null && (r.r.r == null || r.r.r.r == r)) {
+ val err = r.r.r.r // error
+ }
+ }
+}
+

tests/explicit-nulls/neg/flow2.scala

@@ -0,0 +1,18 @@
+
+// Test that flow inference can handle blocks.
+class Foo {
+ val x: String|Null = "hello"
+ if ({val z = 10; {1 + 1 == 2; x != null}}) {
+ val l = x.length
+ }
+
+ if ({x != null; true}) {
+ val l = x.length // error
+ }
+
+ val x2: String|Null = "world"
+ if ({{{{1 + 1 == 2; x != null}}}} && x2 != null) {
+ val l = x.length
+ val l2 = x2.length
+ }
+}

tests/explicit-nulls/neg/flow5.scala

@@ -0,0 +1,66 @@
+
+// Test that flow-sensitive type inference handles
+// early exists from blocks.
+class Foo(x: String|Null) {
+
+ // Test within constructor
+ if (x == null) throw new NullPointerException()
+ val x2: String = x // error: flow inference for blocks doesn't work inside constructors
+
+ def foo(): Unit = {
+ val y: String|Null = ???
+ if (y == null) return ()
+ val y2: String = y // ok
+ }
+
+ def bar(): Unit = {
+ val y: String|Null = ???
+ if (y != null) {
+ } else {
+ return ()
+ }
+ val y2: String = y // ok
+ }
+
+ def fooInExprPos(): String = {
+ val y: String|Null = ???
+ if (y == null) return "foo"
+ y // ok
+ }
+
+ def nonLocalInBlock(): String = {
+ val y: String|Null = ???
+ if (y == null) { println("foo"); return "foo" }
+ y
+ }
+
+ def barWrong(): Unit = {
+ val y: String|Null = ???
+ if (y != null) {
+ return ()
+ } else {
+ }
+ val y2: String = y // error: can't infer that y is non-null (actually, it's the opposite)
+ }
+
+ def err(msg: String): Nothing = {
+ throw new RuntimeException(msg)
+ }
+
+ def retTypeNothing(): String = {
+ val y: String|Null = ???
+ if (y == null) err("y is null!")
+ y
+ }
+
+ def errRetUnit(msg: String): Unit = {
+ throw new RuntimeException(msg)
+ ()
+ }
+
+ def retTypeUnit(): String = {
+ val y: String|Null = ???
+ if (y == null) errRetUnit("y is null!")
+ y // error: previous statement returned unit so can't infer non-nullability
+ }
+}