Pain point using -Yexplicit-nulls with Regex unapply

[griggt]

Compiler version

3.2.0-RC1-bin-20220308-29073f1-NIGHTLY with -Yexplicit-nulls

Minimized code

scala> val Split = "([^#]+)?(?:#(.+)?)?".r
val Split: scala.util.matching.Regex = ([^#]+)?(?:#(.+)?)?

scala> "#foo" match 
     |   case Split(pre, _) if pre != null => println(s"pre=$pre")
     |   case _ => println("no match")
     | 
-- Error: ----------------------------------------------------------------------
2 |  case Split(pre, _) if pre != null => println(s"pre=$pre")
  |                        ^^^^^^^^^^^
  |          Values of types String and Null cannot be compared with == or !=
1 error found

but removing the guard gives:

scala> "#foo" match 
     |   case Split(pre, _) => println(s"pre=$pre")
     |   case _ => println("no match")
     | 
pre=null

Output

As shown above

Expectation

pre is typed as String | Null

Notes

I suspect this is due to #7871?

Is there anything I can do here besides locally importing language.unsafeNulls?

[noti0na1]

Since pre can really be null, the correct type should be List[String | Null]. But I don't think we can modify the type of standard library easily.

One workaround is to cast pre to nullable and then compare:

"#foo" match {
  case Split(pre, _) if (pre: String | Null) != null => println(s"pre=$pre")
  case _ => println("no match")
}

[smarter]

But I don't think we can modify the type of standard library easily.

I think a PR to https://github.com/scala/scala/ that added @Nullable annotations where needed in the standard library could be accepted. Though I guess the annoying part here is that we'd need to create yet another Nullable annotation since scala-library doesn't define one and can't start depending on other jars.

[olhotak]

We could have a @CanEqualNull annotation that allows an expression of a non-null type to be compared against null. We could use it in two places:

1. In the Scala standard library to annotate types of methods such as scala.util.matching.Regex.unapplySeq without breaking binary compatibility.
2. A new language.unsafeJava scope that assigns non-null return types to calls to Java-defined methods. Such a scope would allow member accesses on values returned from Java, but would normally break == null comparison for such values. A @CanEqualNull annotation would fix the latter problem.

@noti0na1 what do you think?