Fix closure check

Author: noti0na1

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

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

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

@@ -110,8 +110,10 @@ 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
+         && (if sym.owner != curCtx.owner then
+              !curCtx.owner.is(Flags.Lazy) // not at the rhs of lazy ValDef
+              && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod // not in different DefDef
+            else true)
          && sym.span.exists
          && curCtx.compilationUnit != null // could be null under -Ytest-pickler
          && curCtx.compilationUnit.assignmentSpans.contains(sym.span.start)
@@ -254,11 +256,16 @@ object Nullables with
 
   given assignOps: (tree: Assign)
     def computeAssignNullable()(given Context): tree.type = tree.lhs match
-      case TrackedRef(ref) => tree.rhs.typeOpt match
-        // If the type of rhs is `T|Null`, then the nullability of the lhs variable is no longer
-        // trackable. We don't need to check whether the type `T` is correct here.
-        case OrNull(_) => tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
-        case _ => tree
+      case TrackedRef(ref) =>
+        def withoutRef: tree.type = tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
+        tree.rhs.typeOpt match
+          // If the type of rhs is `T|Null`, then the nullability of the lhs variable is no longer
+          // trackable. We don't need to check whether the type `T` is correct here, as typer will
+          // check it.
+          case OrNull(_) => withoutRef
+          // If the type of rhs is Null, we discard its NotNullInfo.
+          case tp if tp.isNullType => withoutRef
+          case _ => tree
       case _ => tree
 
   private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)

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

@@ -18,33 +18,19 @@ def f = {
 
 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
+    val a: String = x
+    x = null
+    val b: String = x // error: x is null
   }
 }
 
 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
+  var x: String|Null = ???
+  if (x != null) {
+    val a: String = x
+    val b: String | String = a
+    x = b
+    val _: String = x // ok
   }
 }

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

@@ -0,0 +1,74 @@
+// Test that we don't track variables which is refered in another closure.
+
+object VarRef {
+  locally {
+    var x: String|Null = ???
+    val y = {
+      if (x != null) {
+        val _: String = x // ok: y doesn't create closure
+      }
+    }
+    if (x != null) {
+      val a: String = x // ok
+    }
+  }
+
+  locally {
+    var x: String|Null = ???
+    lazy val y = {
+      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 = ???
+    def y = {
+      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 = "???"
+    lazy val y = {
+      if (x != null) {
+        val a: String = x // error: x exists in closure, no longer tackable
+      }
+      x
+    }
+  }
+
+  locally {
+    var x: String|Null = "???"
+    def y = {
+      if (x != null) {
+        val a: String = x // error: x exists in closure, no longer tackable
+      }
+      x
+    }
+  }
+
+  lazy val lazyblock = {
+    var x: String|Null = "???"
+    lazy val y = {
+      if (x != null) {
+        // The enclosingMethods of x definition and x reference hare are same
+        val a: String = x // error: x exists in closure, no longer tackable
+      }
+      x
+    }
+  }
+}
+