Fix deep NotNullInfo

Author: noti0na1

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

@@ -1058,7 +1058,7 @@ trait Applications extends Compatibility {
             case _ => ()
         else ()
 
-      fun1.tpe match {
+      val result = fun1.tpe match {
         case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs()).withType(err)
         case TryDynamicCallType =>
           val isInsertedApply = fun1 match {
@@ -1132,6 +1132,11 @@ trait Applications extends Compatibility {
                   else tryWithImplicitOnQualifier(fun1, proto).getOrElse(fail))
             }
       }
+
+      if result.tpe.isNothingType then
+        val nnInfo = result.notNullInfo
+        result.withNotNullInfo(nnInfo.terminatedInfo)
+      else result
     }
 
     /** Convert expression like

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

@@ -294,11 +294,29 @@ object Nullables:
       if !info.isEmpty then tree.putAttachment(NNInfo, info)
       tree
 
+    /* Collect the nullability info from parts of `tree` */
+    def collectNotNullInfo(using Context): NotNullInfo = tree match
+      case Typed(expr, _) =>
+        expr.notNullInfo
+      case Apply(fn, args) =>
+        val argsInfo = args.map(_.notNullInfo)
+        val fnInfo = fn.notNullInfo
+        argsInfo.foldLeft(fnInfo)(_ seq _)
+      case TypeApply(fn, _) =>
+        fn.notNullInfo
+      case _ =>
+        // Other cases are handled specially in typer.
+        NotNullInfo.empty
+
     /* The nullability info of `tree` */
     def notNullInfo(using Context): NotNullInfo =
-      stripInlined(tree).getAttachment(NNInfo) match
+      val tree1 = stripInlined(tree)
+      tree1.getAttachment(NNInfo) match
         case Some(info) if !ctx.erasedTypes => info
-        case _ => NotNullInfo.empty
+        case _ =>
+          val nnInfo = tree1.collectNotNullInfo
+          tree1.withNotNullInfo(nnInfo)
+          nnInfo
 
     /* The nullability info of `tree`, assuming it is a condition that evaluates to `c` */
     def notNullInfoIf(c: Boolean)(using Context): NotNullInfo =
@@ -379,21 +397,23 @@ object Nullables:
   end extension
 
   extension (tree: Assign)
-    def computeAssignNullable()(using Context): tree.type = tree.lhs match
-      case TrackedRef(ref) =>
-        val rhstp = tree.rhs.typeOpt
-        if ctx.explicitNulls && ref.isNullableUnion then
-          if rhstp.isNullType || rhstp.isNullableUnion then
-            // If the type of rhs is nullable (`T|Null` or `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.
-            tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
-          else
-            // If the initial type is nullable and the assigned value is non-null,
-            // we add it to the NotNull.
-            tree.withNotNullInfo(NotNullInfo(Set(ref), Set()))
-        else tree
-      case _ => tree
+    def computeAssignNullable()(using Context): tree.type =
+      var nnInfo = tree.rhs.notNullInfo
+      tree.lhs match
+        case TrackedRef(ref) if ctx.explicitNulls && ref.isNullableUnion =>
+          nnInfo = nnInfo.seq:
+            val rhstp = tree.rhs.typeOpt
+            if rhstp.isNullType || rhstp.isNullableUnion then
+              // If the type of rhs is nullable (`T|Null` or `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.
+              NotNullInfo(Set(), Set(ref))
+            else
+              // If the initial type is nullable and the assigned value is non-null,
+              // we add it to the NotNull.
+              NotNullInfo(Set(ref), Set())
+        case _ =>
+      tree.withNotNullInfo(nnInfo)
   end extension
 
   private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)

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

@@ -1000,7 +1000,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             untpd.unsplice(tree.expr).putAttachment(AscribedToUnit, ())
           typed(tree.expr, underlyingTreeTpe.tpe.widenSkolem)
       assignType(cpy.Typed(tree)(expr1, tpt), underlyingTreeTpe)
-        .withNotNullInfo(expr1.notNullInfo)
     }
 
     if (untpd.isWildcardStarArg(tree)) {

tests/explicit-nulls/neg/flow-early-exit.scala

@@ -49,7 +49,7 @@ class Foo(x: String|Null) {
   def retTypeNothing(): String = {
     val y: String|Null = ???
     if (y == null) err("y is null!")
-    y // error
+    y
   }
 
   def errRetUnit(msg: String): Unit = {

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

@@ -19,7 +19,7 @@ class SimpleVar {
     }
 
     assert(x != null)
-    val a: String = x // error
+    val a: String = x
     x = nullable(x)
     val b: String = x // error: x might be null
   }

tests/explicit-nulls/neg/i21619.scala

@@ -76,4 +76,17 @@ def test5: Unit =
   catch
     case _ =>
   val z1: String = x.replace("", "") // error
-  val z2: String = y.replace("", "") // error // LTS specific
+  val z2: String = y.replace("", "") // error // LTS specific
+
+def test6 = {
+  var x: String | Null = ""
+  var y: String = ""
+  x = ""
+  y = if (false) x else 1 match { // error
+    case _ => {
+      x = null
+      y
+    }
+  }
+  x.replace("", "") // error
+}