Address new warnings with the stricter patmat exhaustivity of 2.13.4.

In 2.13.4, the pattern match exhaustivity analysis has become
stricter. It remains active in the presence of guards and custom
extractors (including `unapplySeq`). This change causes some new
warnings in our codebase, which this commit addresses.

See scala/scala#9140, which was somewhat
toned down by scala/scala#9299.

compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

@@ -1652,6 +1652,8 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
             (Nil, applyCtor)
           case js.Block(prepStats :+ (applyCtor: js.ApplyStatic)) =>
             (prepStats, applyCtor)
+          case _ =>
+            abort(s"Unexpected body for JS constructor dispatch resolution at ${body.pos}:\n$body")
         }
         val js.ApplyStatic(_, _, js.MethodIdent(ctorName), js.This() :: ctorArgs) =
           applyCtor
@@ -1731,6 +1733,9 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
                 if method.name.isConstructor =>
               method.name
           }.get
+
+        case _ =>
+          abort(s"Unexpected secondary constructor body at ${tree.pos}:\n$tree")
       }
 
       val (primaryCtor :: Nil, secondaryCtors) = ctors.partition {
@@ -5207,13 +5212,14 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
                 s"wrong number of arguments for call to JS setter $sym at $pos")
             genSelectSet(jsFunName, argsNoSpread.head)
           } else if (jsInterop.isJSBracketAccess(sym)) {
-            assert(argc == 1 || argc == 2,
-                s"@JSBracketAccess methods should have 1 or 2 non-varargs arguments")
             argsNoSpread match {
-              case List(keyArg) =>
+              case keyArg :: Nil =>
                 genSelectGet(keyArg)
-              case List(keyArg, valueArg) =>
+              case keyArg :: valueArg :: Nil =>
                 genSelectSet(keyArg, valueArg)
+              case _ =>
+                throw new AssertionError(
+                    s"@JSBracketAccess methods should have 1 or 2 non-varargs arguments at $pos")
             }
           } else if (jsInterop.isJSBracketCall(sym)) {
             val (methodName, actualArgs) = extractFirstArg(args)

compiler/src/main/scala/org/scalajs/nscplugin/PrepJSInterop.scala

@@ -166,7 +166,8 @@ abstract class PrepJSInterop[G <: Global with Singleton](val global: G)
 
       checkJSNameAnnots(sym)
 
-      val transformedTree: Tree = tree match {
+      // @unchecked needed because MemberDef is not marked `sealed`
+      val transformedTree: Tree = (tree: @unchecked) match {
         case tree: ImplDef =>
           if (shouldPrepareExports)
             registerClassOrModuleExports(sym)
@@ -828,6 +829,9 @@ abstract class PrepJSInterop[G <: Global with Singleton](val global: G)
             }
             Some(loadSpec)
 
+          case Some(annot) =>
+            abort(s"checkAndGetJSNativeLoadingSpecAnnotOf returned unexpected annotation $annot")
+
           case None =>
             /* We already emitted an error. Invent something not to cause
              * cascading errors.

linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala

@@ -582,8 +582,7 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
           }
 
         case Assign(select @ ArraySelect(array, index), rhs) =>
-          unnest(List(array, index, rhs)) {
-            case (List(newArray, newIndex, newRhs), env0) =>
+          unnest(array, index, rhs) { (newArray, newIndex, newRhs, env0) =>
               implicit val env = env0
               val genArray = transformExprNoChar(newArray)
               val genIndex = transformExprNoChar(newIndex)
@@ -616,8 +615,8 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
           }
 
         case Assign(select @ JSSelect(qualifier, item), rhs) =>
-          unnest(List(qualifier, item, rhs)) {
-            case (List(newQualifier, newItem, newRhs), env0) =>
+          unnest(qualifier, item, rhs) {
+            (newQualifier, newItem, newRhs, env0) =>
               implicit val env = env0
               js.Assign(
                   genBracketSelect(transformExprNoChar(newQualifier),
@@ -626,8 +625,8 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
           }
 
         case Assign(select @ JSSuperSelect(superClass, qualifier, item), rhs) =>
-          unnest(List(superClass, qualifier, item, rhs)) {
-            case (List(newSuperClass, newQualifier, newItem, newRhs), env0) =>
+          unnest(superClass, qualifier, item, rhs) {
+            (newSuperClass, newQualifier, newItem, newRhs, env0) =>
               implicit val env = env0
               genCallHelper("superSet", transformExprNoChar(newSuperClass),
                   transformExprNoChar(newQualifier), transformExprNoChar(item),
@@ -1070,17 +1069,39 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
     /** Same as above, for a single argument */
     def unnest(arg: Tree)(makeStat: (Tree, Env) => js.Tree)(
         implicit env: Env): js.Tree = {
-      unnest(List(arg)) {
-        case (List(newArg), env) => makeStat(newArg, env)
+      unnest(List(arg)) { (newArgs, env) =>
+        val newArg :: Nil = newArgs
+        makeStat(newArg, env)
       }
     }
 
     /** Same as above, for two arguments */
-    def unnest(lhs: Tree, rhs: Tree)(
+    def unnest(arg1: Tree, arg2: Tree)(
         makeStat: (Tree, Tree, Env) => js.Tree)(
         implicit env: Env): js.Tree = {
-      unnest(List(lhs, rhs)) {
-        case (List(newLhs, newRhs), env) => makeStat(newLhs, newRhs, env)
+      unnest(List(arg1, arg2)) { (newArgs, env) =>
+        val newArg1 :: newArg2 :: Nil = newArgs
+        makeStat(newArg1, newArg2, env)
+      }
+    }
+
+    /** Same as above, for 3 arguments */
+    def unnest(arg1: Tree, arg2: Tree, arg3: Tree)(
+        makeStat: (Tree, Tree, Tree, Env) => js.Tree)(
+        implicit env: Env): js.Tree = {
+      unnest(List(arg1, arg2, arg3)) { (newArgs, env) =>
+        val newArg1 :: newArg2 :: newArg3 :: Nil = newArgs
+        makeStat(newArg1, newArg2, newArg3, env)
+      }
+    }
+
+    /** Same as above, for 4 arguments */
+    def unnest(arg1: Tree, arg2: Tree, arg3: Tree, arg4: Tree)(
+        makeStat: (Tree, Tree, Tree, Tree, Env) => js.Tree)(
+        implicit env: Env): js.Tree = {
+      unnest(List(arg1, arg2, arg3, arg4)) { (newArgs, env) =>
+        val newArg1 :: newArg2 :: newArg3 :: newArg4 :: Nil = newArgs
+        makeStat(newArg1, newArg2, newArg3, newArg4, env)
       }
     }
 
@@ -1702,8 +1723,8 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
           }
 
         case JSSuperSelect(superClass, qualifier, item) =>
-          unnest(List(superClass, qualifier, item)) {
-            case (List(newSuperClass, newQualifier, newItem), env) =>
+          unnest(superClass, qualifier, item) {
+            (newSuperClass, newQualifier, newItem, env) =>
               redo(JSSuperSelect(newSuperClass, newQualifier, newItem))(env)
           }