Improve warning for wildcard matching non-nullable types (scala#21577)

Adds a more detailed warning message when a wildcard case is unreachable on an
non-nullable type to suggest adding a nullable type annotation.

Fixes scala#21577

Author: HarrisL2

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -935,6 +935,13 @@ extends PatternMatchMsg(MatchCaseOnlyNullWarningID) {
   def explain(using Context) = ""
 }
 
+class MatchCaseNonNullableWildcardWarning()(using Context)
+extends Message(MatchCaseUnreachableID) {
+  def kind = MessageKind.MatchCaseUnreachable
+  def msg(using Context) = i"""Unreachable case (if expression is expected to be nullable, consider giving it a nullable type annotation)."""
+  def explain(using Context) = ""
+}
+
 class MatchableWarning(tp: Type, pattern: Boolean)(using Context)
 extends TypeMsg(MatchableWarningID) {
   def msg(using Context) =

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -903,6 +903,8 @@ object SpaceEngine {
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
     )
+    // println(s"${toUnderlying(m.selector.tpe)}")
+    // println(s"${selTyp} \n${isNullable} \n${targetSpace}")
 
     var i        = 0
     val len      = cases.length
@@ -925,11 +927,18 @@ object SpaceEngine {
           report.warning(MatchCaseUnreachable(), pat.srcPos)
         if pat != EmptyTree // rethrow case of catch uses EmptyTree
             && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
-            && isSubspace(covered, prev)
+            && isSubspace(covered, Or(List(prev, Typ(defn.NullType))))
         then {
-          val nullOnly = isNullable && i == len - 1 && isWildcardArg(pat)
-          val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
-          report.warning(msg, pat.srcPos)
+          if isSubspace(covered, prev) then {
+            val nullOnly = (isNullable
+              || (defn.NullType <:< selTyp)
+            ) && i == len - 1 && isWildcardArg(pat)
+            val msg =
+              if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
+            report.warning(msg, pat.srcPos)
+          } else {
+            report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
+          }
         }
         deferred = Nil
       }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -212,6 +212,11 @@ class CompilationTests {
     )
   }.checkCompile()
 
+  @Test def explicitNullsWarn: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("explicitNullsWarn")
+    compileFilesInDir("tests/explicit-nulls/warn", explicitNullsOptions)
+  }.checkWarnings()
+
   @Test def explicitNullsRun: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsRun")
     compileFilesInDir("tests/explicit-nulls/run", explicitNullsOptions)

tests/explicit-nulls/warn/i21577.check

@@ -0,0 +1,12 @@
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:5:9 --------------------------------------------
+5 |    case _ => println(2) // warn
+  |         ^
+  |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:12:11 ------------------------------------------
+12 |      case _ => println(2) // warn
+   |           ^
+   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:18:11 ------------------------------------------
+18 |      case _ => println(2) // warn
+   |           ^
+   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).

tests/explicit-nulls/warn/i21577.scala

@@ -0,0 +1,24 @@
+def f(s: String) =
+  val s2 = s.trim()
+  s2 match
+    case s3: String => println(1)
+    case _ => println(2) // warn
+
+
+def f2(s: String | Null) =
+  val s2 = s.nn.trim()
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2) // warn
+
+def f3(s: String | Null) =
+  val s2 = s
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2) // warn
+
+def f4(s: String | Int) =
+  val s2 = s
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2)