Fix isStable; fix var track in lazy val

Author: noti0na1

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

@@ -270,7 +270,7 @@ class Definitions {
     @tu lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
     @tu lazy val Any_typeTest: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic | Artifact)
     @tu lazy val Any_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | StableRealizable)
-      // generated by pattern matcher, eliminated by erasure
+      // generated by pattern matcher and exlicit nulls, eliminated by erasure
 
     /** def getClass[A >: this.type](): Class[? <: A] */
     @tu lazy val Any_getClass: TermSymbol =
@@ -320,8 +320,7 @@ class Definitions {
 
   /** Methods in Object and Any that do not have a side effect */
   @tu lazy val pureMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-    Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_typeTest, Object_eq, Object_ne,
-    Compiletime_notNull.asInstanceOf[TermSymbol])
+    Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_typeTest, Object_eq, Object_ne)
 
   @tu lazy val AnyKindClass: ClassSymbol = {
     val cls = ctx.newCompleteClassSymbol(ScalaPackageClass, tpnme.AnyKind, AbstractFinal | Permanent, Nil)

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

@@ -17,6 +17,7 @@ import SymDenotations._
 import Decorators._
 import Denotations._
 import Periods._
+import CheckRealizable._
 import util.Stats._
 import util.SimpleIdentitySet
 import reporting.diagnostic.Message
@@ -163,7 +164,9 @@ object Types {
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.parent.isStable
-      case tp: AndType => tp.tp1.isStable || tp.tp2.isStable
+      case tp: AndType =>
+        tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
+        tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
       case _ => false
     }
 

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

@@ -823,9 +823,12 @@ trait Implicits { self: Typer =>
           // if (x.asInstanceOf[String|Null] == null) {} // ok
           cls1 == defn.NullClass && cls1 == cls2
         else if (cls1 == defn.NullClass)
-          cls1 == cls2 || cls2.derivesFrom(defn.ObjectClass)
-        else if (cls2 == defn.NullClass)
-          cls1.derivesFrom(defn.ObjectClass)
+          cls1 == cls2
+        else if (!ctx.explicitNulls)
+          if (cls1 == defn.NullClass)
+            cls2.derivesFrom(defn.ObjectClass)
+          else
+            cls2 == defn.NullClass && cls1.derivesFrom(defn.ObjectClass)
         else
           false
       }

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

@@ -110,6 +110,7 @@ object Nullables with
     || { val sym = ref.symbol
          sym.is(Mutable)
          && sym.owner.isTerm
+         && !curCtx.owner.is(Flags.Lazy) // not a rhs of lazy ValDef
          && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod
          && sym.span.exists
          && curCtx.compilationUnit != null // could be null under -Ytest-pickler

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

@@ -352,15 +352,12 @@ 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))
-      //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(
+      // val tpeA = TypeTree(tpnn)
+      // val tpeB = TypeTree(AndType(ref, tpnn))
+      // Apply(
       //   TypeApply(Ident(defn.Compiletime_notNull.namedType), tpeA :: tpeB :: Nil),
       //   tree :: Nil)
-      newTree
+      tree.select(defn.Any_typeCast).appliedToType(AndType(ref, tpnn))
     case _ =>
       tree
 

tests/explicit-nulls/neg/after-assign.scala

@@ -0,0 +1,13 @@
+class C(val x: Int, val next: C|Null)
+
+def f = {
+  var xs: C|Null = C(1, C(2, null))
+  while (xs != null) {
+    val xsx: Int = xs.x
+    val xscpy: C = xs
+    xs = xscpy // Since xscpy is non-nullable, after the assign, xs is still non-nullable
+    val xscpyx: Int = xscpy.x
+    xs = xs.next // xs.next is nullable, after the assign, xs becomes nullable
+    val xsnx: Int = xs.x // error
+  }
+}

tests/explicit-nulls/neg/eq.scala

@@ -41,4 +41,4 @@ class Foo {
   null == false // error
   'a' == null   // error
   null == 'b'   // error
-}
+}

tests/explicit-nulls/neg/simple-var.scala

@@ -0,0 +1,50 @@
+// Test simple var track
+
+def nullable[T](x: T): T|Null = x
+
+def f = {
+  var x: String|Null = ???
+  if (x != null) {
+    val a: String = x
+    x = ""
+    val b: String = x
+  }
+
+  assert(x != null)
+  val a: String = x
+  x = nullable(x)
+  val b: String = x // error: x might be null
+}
+
+def g = {
+  var x: String|Null = ???
+  lazy val y = {
+    if (x != null) {
+      x = null
+    }
+
+  }
+  if (x != null) {
+    val a: String = x // error: x exists in closure, no longer tackable
+  }
+}
+
+def h = {
+  var x: String|Null = "???"
+  lazy val y = {
+    if (x != null) {
+      val a: String = x // error: x exists in closure, no longer tackable
+    }
+    x
+  }
+}
+
+def i = {
+  var x: String|Null = "???"
+  def y = {
+    if (x != null) {
+      val a: String = x // error: x exists in closure, no longer tackable
+    }
+    x
+  }
+}

tests/explicit-nulls/neg/strip.scala

@@ -20,8 +20,6 @@ class Foo {
 
   locally {
     val x: (Null | B1) & B2 = ???
-    if (x != null) {
-      val _: B1 & B2 = x // error: the type of x is not a nullable union, so we cannot remove the Null
-    }
+    if (x != null) {} // error: the type of x is not a nullable union, so we cannot remove the Null
   }
 }

tests/explicit-nulls/pos/flow3.scala

@@ -1,6 +1,7 @@
-
+// TODO: broken
 // Test that flow inference can look inside type ascriptions.
 // This is useful in combination with inlining (because inlined methods have an ascribed return type).
+
 class Foo {
   val x: String|Null = "hello"