Track nullability in pattern matches

Author: odersky

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -434,9 +434,9 @@ class TreeChecker extends Phase with SymTransformer {
         }
       }
 
-    override def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type)(implicit ctx: Context): CaseDef =
+    override def typedCase(tree: untpd.CaseDef, sel: Tree, selType: Type, pt: Type)(implicit ctx: Context): CaseDef =
       withPatSyms(tpd.patVars(tree.pat.asInstanceOf[tpd.Tree])) {
-        super.typedCase(tree, selType, pt)
+        super.typedCase(tree, sel, selType, pt)
       }
 
     override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = {

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

@@ -65,6 +65,20 @@ object Nullables with
   /** Is given reference tracked for nullability? */
   def isTracked(ref: TermRef)(given Context) = ref.isStable
 
+  def afterPatternContext(sel: Tree, pat: Tree)(given ctx: Context) = (sel, pat) match
+    case (TrackedRef(ref), Literal(Constant(null))) => ctx.addExcluded(Set(ref))
+    case _ => ctx
+
+  def caseContext(sel: Tree, pat: Tree)(given ctx: Context): Context = sel match
+    case TrackedRef(ref) if matchesNotNull(pat) => ctx.addExcluded(Set(ref))
+    case _ => ctx
+
+  private def matchesNotNull(pat: Tree)(given Context): Boolean = pat match
+    case _: Typed | _: UnApply => true
+    case Alternative(pats) => pats.forall(matchesNotNull)
+    // TODO: Add constant pattern if the constant type is not nullable
+    case _ => false
+
   given (excluded: List[Excluded])
     def containsRef(ref: TermRef): Boolean =
       excluded.exists(_.contains(ref))

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

@@ -1138,13 +1138,18 @@ class Typer extends Namer
 
   // Overridden in InlineTyper for inline matches
   def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context): Tree = {
-    val cases1 = harmonic(harmonize, pt)(typedCases(cases, wideSelType, pt.dropIfProto))
+    val cases1 = harmonic(harmonize, pt)(typedCases(cases, sel, wideSelType, pt.dropIfProto))
       .asInstanceOf[List[CaseDef]]
     assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
   }
 
-  def typedCases(cases: List[untpd.CaseDef], selType: Type, pt: Type)(implicit ctx: Context): List[CaseDef] =
-    cases.mapconserve(typedCase(_, selType, pt))
+  def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType: Type, pt: Type)(implicit ctx: Context): List[CaseDef] =
+    var caseCtx = ctx
+    cases.mapconserve { cas =>
+      val case1 = typedCase(cas, sel, wideSelType, pt)(given caseCtx)
+      caseCtx = Nullables.afterPatternContext(sel, case1.pat)
+      case1
+    }
 
   /** - strip all instantiated TypeVars from pattern types.
     *    run/reducable.scala is a test case that shows stripping typevars is necessary.
@@ -1171,7 +1176,7 @@ class Typer extends Namer
   }
 
   /** Type a case. */
-  def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type)(implicit ctx: Context): CaseDef = {
+  def typedCase(tree: untpd.CaseDef, sel: Tree, wideSelType: Type, pt: Type)(implicit ctx: Context): CaseDef = {
     val originalCtx = ctx
     val gadtCtx: Context = ctx.fresh.setFreshGADTBounds
 
@@ -1184,8 +1189,10 @@ class Typer extends Namer
       assignType(cpy.CaseDef(tree)(pat1, guard1, body1), pat1, body1)
     }
 
-    val pat1 = typedPattern(tree.pat, selType)(gadtCtx)
-    caseRest(pat1)(gadtCtx.fresh.setNewScope)
+    val pat1 = typedPattern(tree.pat, wideSelType)(gadtCtx)
+    caseRest(pat1)(
+      given Nullables.caseContext(sel, pat1)(
+        given gadtCtx.fresh.setNewScope))
   }
 
   def typedLabeled(tree: untpd.Labeled)(implicit ctx: Context): Labeled = {
@@ -1205,7 +1212,6 @@ class Typer extends Namer
     caseRest(ctx.fresh.setFreshGADTBounds.setNewScope)
   }
 
-
   def typedReturn(tree: untpd.Return)(implicit ctx: Context): Return = {
     def returnProto(owner: Symbol, locals: Scope): Type =
       if (owner.isConstructor) defn.UnitType
@@ -1263,7 +1269,7 @@ class Typer extends Namer
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = {
     val expr2 :: cases2x = harmonic(harmonize, pt) {
       val expr1 = typed(tree.expr, pt.dropIfProto)
-      val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.dropIfProto)
+      val cases1 = typedCases(tree.cases, EmptyTree, defn.ThrowableType, pt.dropIfProto)
       expr1 :: cases1
     }
     val finalizer1 = typed(tree.finalizer, defn.UnitType)

tests/pos/nullable.scala

@@ -30,6 +30,19 @@ def test: Unit =
   }
   then ()
 
+  x match
+    case _: String =>
+      if x == null then impossible(new T{})
+
+  val y: Any = List(x)
+  y match
+    case y1 :: ys => if y == null then impossible(new T{})
+    case Some(_) | Seq(_: _*) => if y == null then impossible(new T{})
+
+  x match
+    case null =>
+    case _ => if x == null then impossible(new T{})
+
   if x == null then return
   if x == null then impossible(new T{})