add usedOutOfOrder

Author: noti0na1

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

@@ -9,7 +9,7 @@ import StdNames.nme
 import util.Property
 import Names.Name
 import util.Spans.Span
-import Flags.Mutable
+import Flags._
 import NullOpsDecorator._
 import collection.mutable
 
@@ -151,11 +151,7 @@ object Nullables with
     || { val sym = ref.symbol
          sym.is(Mutable)
          && sym.owner.isTerm
-         && ( sym.owner == curCtx.owner
-          || !curCtx.owner.is(Flags.Lazy) // not at the rhs of lazy ValDef
-            && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod // not in different methods
-            // TODO: need to check by-name paramter
-          )
+         && !ref.usedOutOfOrder // todo: remove
          && sym.span.exists
          && curCtx.compilationUnit != null // could be null under -Ytest-pickler
          && curCtx.compilationUnit.assignmentSpans.contains(sym.span.start)
@@ -206,6 +202,24 @@ object Nullables with
       then infos
       else info :: infos
 
+  given refOps: extension (ref: TermRef) with
+
+    def usedOutOfOrder(given Context) =
+      val refSym = ref.symbol
+      val refOwner = refSym.owner
+
+      def enclosedInClosure(s: Symbol): Boolean =
+        s != NoSymbol
+        && s != refOwner
+        && (s.isOneOf(Lazy | Method) // not at the rhs of lazy ValDef or in a method (or lambda)
+          || s.isClass // not in a class
+          // TODO: need to check by-name paramter
+          || enclosedInClosure(s.owner))
+
+      refSym.is(Mutable)
+      && refSym.owner.isTerm
+      && enclosedInClosure(curCtx.owner)
+
   given treeOps: extension (tree: Tree) with
 
     /* The `tree` with added nullability attachment */

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

@@ -353,6 +353,7 @@ class Typer extends Namer
   def toNotNullTermRef(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree.tpe match
     case ref @ OrNull(tpnn) : TermRef
     if pt != AssignProto && // Ensure it is not the lhs of Assign
+    !ref.usedOutOfOrder &&
     ctx.notNullInfos.impliesNotNull(ref) =>
       tree.select(defn.Any_typeCast).appliedToType(AndType(ref, tpnn))
     case _ =>

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

@@ -13,6 +13,18 @@ object VarRef {
     }
   }
 
+  locally {
+    var x: String|Null = ???
+    var 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 = {