Fix effects checking for rethrowing functions involving parameter packs

Effects checking for rethrowing functions was using unsubstituted
interface types for the parameter list. When a rethrows function has
parameter pack arguments, the interface type may have a different
number of parameters from the resulting argument list, causing the
effects checking to bail out early.

This has been wrong since the introduction of parameter packs, but
recent refactoring of effects checking ended up promoting this bug to
a compiler crash. Fix the bug, and make sure we don't crash if the
effects checker hits an issue here.

Fixes rdar://116740385.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -1173,14 +1173,21 @@ class ApplyClassifier {
         // because it only counts for rethrows/reasync purposes if it
         // lines up with a throws/async function parameter in the
         // original type.
-        auto *origType = fnRef.getType()->getAs<AnyFunctionType>();
-        if (!origType) {
+        Type fnInterfaceType = fnRef.getType();
+        if (!fnInterfaceType) {
           result.merge(Classification::forInvalidCode());
           return;
         }
 
         // Use the most significant result from the arguments.
-        auto params = origType->getParams();
+        auto *fnSubstType = fnInterfaceType.subst(fnRef.getSubstitutions())
+            ->getAs<AnyFunctionType>();
+        if (!fnSubstType)  {
+          result.merge(Classification::forInvalidCode());
+          return;
+        }
+
+        auto params = fnSubstType->getParams();
         if (params.size() != args->size()) {
           result.merge(Classification::forInvalidCode());
           return;
@@ -2914,6 +2921,9 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
 
       auto asyncKind = classification.getConditionalKind(EffectKind::Async);
       E->setNoAsync(asyncKind == ConditionalEffectKind::None);
+    } else {
+      E->setThrows(ThrownErrorDestination());
+      E->setNoAsync(true);
     }
 
     // If current apply expression did not type-check, don't attempt

test/decl/func/rethrows.swift

@@ -659,3 +659,25 @@ protocol P1 {
 func open(p: any P1, s: any Sequence) throws {
   _ = p.test(s).map(\.id)
 }
+
+// Rethrows checking and parameter packs, oh my.
+func rethrowsWithParameterPacks<each Arg>(_ arguments: repeat each Arg, body: () throws -> Void) rethrows { }
+
+enum MyError: Error {
+case fail
+}
+
+func testRethrowsWithParameterPacks() throws {
+  try rethrowsWithParameterPacks { throw MyError.fail }
+  rethrowsWithParameterPacks { }
+
+  try rethrowsWithParameterPacks(1) { throw MyError.fail }
+  rethrowsWithParameterPacks(1) { }
+
+  try rethrowsWithParameterPacks(1, "hello") { throw MyError.fail }
+  rethrowsWithParameterPacks(1, "hello") { }
+
+  rethrowsWithParameterPacks { throw MyError.fail }
+  // expected-error@-1{{call can throw but is not marked with 'try'}}
+  // expected-note@-2{{call is to 'rethrows' function, but argument function can throw}}
+}