Check for mismatched argument type length in PatternMatcher due to Named Tuple :* syntax (scala#23602)

Fixes scala#23155

After discussing at the compiler meeting, it was decided that the Named
Tuple behavior should be the same as the Tuple behavior with respect to
pattern matching with the `:*` syntax. To error in the exact same way,
it should be caught here:
https://github.com/scala/scala3/blob/00d19dfd0906d2b4a8c076ded8af15cc3a6f2dc9/compiler/src/dotty/tools/dotc/typer/Applications.scala#L291

For regular tuples, `argTypes` is an `AppliedType` of `:*` and is not
yet reduced, so has length 1, so the arity check will fail. However, at
this point Named Tuple types are fully reduced by `tupleElementTypes`
here:
https://github.com/scala/scala3/blob/00d19dfd0906d2b4a8c076ded8af15cc3a6f2dc9/compiler/src/dotty/tools/dotc/typer/Applications.scala#L249

So for Named Tuples, `argTypes` at the time of the check will be `(Int,
Int)` so the arity check will pass, causing a later crash in
PatternMatcher here:
https://github.com/scala/scala3/blob/6146b90b8e32ac81d2703fccdebbc85e72cc5c5b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala#L270

We cannot un-reduce or fail to reduce for Named Tuple types because it
will cause a host of other tests to fail that rely on the fully reduced
Named Tuple-value types. For now I have added a check in PatternMatcher
because it’s better to fix the compiler crash ASAP, but I think we could
revisit if we want something like `Int :* Int :* EmptyTuple` to really
behave differently from `(Int, Int)` here, since pattern matching
currently works for both Tuples and Named Tuples using `(Int, Int)` or
`Tuple2[Int, Int]` , just not `:*`.

Author: aherlihy

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

@@ -267,8 +267,14 @@ object PatternMatcher {
         def matchArgsPatternPlan(args: List[Tree], syms: List[Symbol]): Plan =
           args match {
             case arg :: args1 =>
-              val sym :: syms1 = syms: @unchecked
-              patternPlan(sym, arg, matchArgsPatternPlan(args1, syms1))
+              if (args.length != syms.length)
+                report.error(UnapplyInvalidNumberOfArguments(tree, tree.tpe :: Nil), arg.srcPos)
+                // Generate a throwaway but type-correct plan.
+                // This plan will never execute because it'll be guarded by a `NonNullTest`.
+                ResultPlan(tpd.Throw(tpd.nullLiteral))
+              else
+                val sym :: syms1 = syms: @unchecked
+                patternPlan(sym, arg, matchArgsPatternPlan(args1, syms1))
             case Nil =>
               assert(syms.isEmpty)
               onSuccess

tests/neg/i23155a.scala

@@ -0,0 +1,7 @@
+import scala.NamedTuple
+object Unpack_NT {
+  (1, 2) match {
+    case Unpack_NT(first, _) => first // error
+  }
+  def unapply(e: (Int, Int)): Some[NamedTuple.NamedTuple["x" *: "y" *: EmptyTuple, Int *: Int *: EmptyTuple]] = ???
+}

tests/neg/i23155b.scala

@@ -0,0 +1,6 @@
+object Unpack_T {
+  (1, 2) match {
+    case Unpack_T(first, _) => first // error
+  }
+  def unapply(e: (Int, Int)): Some[Int *: Int *: EmptyTuple] = ???
+}