Fix #5067: Ycheck failure in pattern matching against a value of type Nothing

When desugaring pattern matching code for expressions where the
matched value has type `Null` or `Nothing`, we used to generate code
that's type-incorrect.

Example:
```
val Some(x) = null
```

got desugared into
```
val x: Nothing =
      matchResult1[Nothing]:
        {
          case val x1: Null @unchecked = null: Null @unchecked
          if x1.ne(null) then
            {
              case val x: Nothing = x1.value.asInstanceOf[Nothing]
              return[matchResult1] x: Nothing
            }
           else ()
          return[matchResult1] throw new MatchError(x1)
        }
```

There were two problems here:
1) `x1.ne(null)`
2) `x1.value`

In both cases, we're trying to invoke methods that don't exist for type
`Nothing` (and #2 doesn't exist for `Null`).

This commit changes the desugaring so we generate a no-op for unapply
when the value matched has type `Nothing` or `Null`. This works because
the code we used to generate is never executed (because the `x1.ne(null)`) check.

Author: abeln

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -233,6 +233,12 @@ object Types {
         }
       }
 
+    /** Is this type exactly Null (no vars, aliases, refinements etc allowed)? */
+    def isNullType(implicit ctx: Context): Boolean = this match {
+      case tp: TypeRef => tp.symbol eq defn.NullClass
+      case _ => false
+    }
+
     /** Is this type exactly Nothing (no vars, aliases, refinements etc allowed)? */
     def isBottomType(implicit ctx: Context): Boolean = this match {
       case tp: TypeRef => tp.symbol eq defn.NothingClass

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

@@ -144,6 +144,7 @@ object PatternMatcher {
     case class ReturnPlan(var label: TermSymbol) extends Plan
     case class SeqPlan(var head: Plan, var tail: Plan) extends Plan
     case class ResultPlan(var tree: Tree) extends Plan
+    case object NoOpPlan extends Plan
 
     object TestPlan {
       def apply(test: Test, sym: Symbol, pos: Position, ons: Plan): TestPlan =
@@ -332,9 +333,19 @@ object PatternMatcher {
           val mt @ MethodType(_) = extractor.tpe.widen
           var unapp = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
           if (implicits.nonEmpty) unapp = unapp.appliedToArgs(implicits)
-          val unappPlan = unapplyPlan(unapp, args)
-          if (scrutinee.info.isNotNull || nonNull(scrutinee)) unappPlan
-          else TestPlan(NonNullTest, scrutinee, tree.pos, unappPlan)
+          val scrutineeTpe = scrutinee.info.widenDealias
+          if (scrutineeTpe.isBottomType || scrutineeTpe.isNullType) {
+            // If the value being matched against has type `Nothing`, then the unapply code
+            // will never execute.
+            // If it has type `Null`, then the `NonNullTest` below guarantees that the unapply code
+            // won't execute either.
+            // So we don't need a plan in this case.
+            NoOpPlan
+          } else {
+            val unappPlan = unapplyPlan(unapp, args)
+            if (scrutinee.info.isNotNull || nonNull(scrutinee)) unappPlan
+            else TestPlan(NonNullTest, scrutinee, tree.pos, unappPlan)
+          }
         case Bind(name, body) =>
           if (name == nme.WILDCARD) patternPlan(scrutinee, body, onSuccess)
           else {
@@ -407,13 +418,15 @@ object PatternMatcher {
         plan.tail = apply(plan.tail)
         plan
       }
+      def applyNoOp: Plan = NoOpPlan
       def apply(plan: Plan): Plan = plan match {
         case plan: TestPlan => apply(plan)
         case plan: LetPlan => apply(plan)
         case plan: LabeledPlan => apply(plan)
         case plan: ReturnPlan => apply(plan)
         case plan: SeqPlan => apply(plan)
         case plan: ResultPlan => plan
+        case NoOpPlan => applyNoOp
       }
     }
 
@@ -662,7 +675,7 @@ object PatternMatcher {
     @tailrec
     private def canFallThrough(plan: Plan): Boolean = plan match {
       case _:ReturnPlan | _:ResultPlan => false
-      case _:TestPlan | _:LabeledPlan => true
+      case _:TestPlan | _:LabeledPlan | NoOpPlan => true
       case LetPlan(_, body) => canFallThrough(body)
       case SeqPlan(_, tail) => canFallThrough(tail)
     }
@@ -820,6 +833,9 @@ object PatternMatcher {
           }
         case ResultPlan(tree) =>
           Return(tree, ref(resultLabel))
+        case NoOpPlan =>
+          // TODO(abeln): optimize away
+          Literal(Constant(true))
       }
     }
 
@@ -858,6 +874,8 @@ object PatternMatcher {
               showPlan(tail)
             case ResultPlan(tree) =>
               sb.append(tree.show)
+            case NoOpPlan =>
+              sb.append("NoOp")
           }
         }
       showPlan(plan)

tests/pos/i5067.scala

@@ -0,0 +1,10 @@
+class Foo {
+  val Some(_) = null
+  val Some(_) = ???
+  val (_, _) = null
+  val (_, _, _) = ???
+  ??? match {
+    case Some(_) => ()
+    case (_, _, _) => ()
+  }
+}

tests/run/i5067.check

@@ -0,0 +1 @@
+matches null literal

tests/run/i5067.scala

@@ -0,0 +1,9 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    null match {
+      case Some(_) => println("matches Some")
+      case (_, _) => println("matches Pair")
+      case null => println("matches null literal")
+    }
+  }
+}