[Typed throws] Rethrows functions always throw any Error

Rethrows functions only throw when their closure arguments throw.
However, they are free to translate the errors thrown from the closure
arguments in any way they want, and are therefore untyped.

Ensure that calls to `rethrows` functions are always treated as
throwing `any Error` if their closure arguments throw anything.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -718,6 +718,17 @@ class Classification {
     return result;
   }
 
+  /// Return a classification that promotes a typed throws effect to an
+  /// untyped throws effect.
+  Classification promoteToUntypedThrows() const {
+    if (!hasThrows())
+      return *this;
+
+    Classification result(*this);
+    result.ThrownError = ThrownError->getASTContext().getErrorExistentialType();
+    return result;
+  }
+
   /// Return a classification that only retains the parts of this
   /// classification for the requested effect kind.
   Classification onlyEffect(EffectKind kind) const {
@@ -1109,9 +1120,15 @@ class ApplyClassifier {
         }
 
         for (unsigned i = 0, e = params.size(); i < e; ++i) {
-          result.merge(classifyArgument(args->getExpr(i),
-                                        params[i].getParameterType(),
-                                        kind));
+          auto argClassification = classifyArgument(
+              args->getExpr(i), params[i].getParameterType(), kind);
+
+          // Rethrows is untyped, so
+          if (kind == EffectKind::Throws) {
+            argClassification = argClassification.promoteToUntypedThrows();
+          }
+
+          result.merge(argClassification);
         }
 
         return;

test/decl/func/typed_throws.swift

@@ -146,3 +146,11 @@ extension Either: Error where First: Error, Second: Error { }
 func f<E1, E2>(_ error: Either<E1, E2>) throws(Either<E1, E2>) {
   throw error
 }
+
+// Ensure that calls to 'rethrows' functions are always treated as throwing `any
+// Error`.
+func rethrowingFunc(body: () throws -> Void) rethrows { }
+
+func typedCallsRethrowingFunc<E>(body: () throws(E) -> Void) throws(E) {
+  try rethrowingFunc(body: body) // expected-error{{thrown expression type 'any Error' cannot be converted to error type 'E'}}
+}