[Typed throws] Add compatibility carve-out within rethrows functions

Allow a rethrows function to call a typed-throws function that has a
specific form that looks like it only rethrows, i.e., it is generic
over its thrown error type and carries the thrown error type from its
closure parameters to itself. This is a compatibility carve-out to
allow existing rethrows functions to move to typed throws without
breaking their clients.

Note that it is possible to write a sneaky function that passes this
check but throws when it shouldn't, so this compatibility carve-out is
phased out with the upcoming feature FullTypedThrows.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -637,6 +637,59 @@ static Expr *removeErasureToExistentialError(Expr *expr) {
   return expr;
 }
 
+/// Determine whether the given function uses typed throws in a manner
+/// than is structurally similar to 'rethrows', e.g.,
+///
+/// \code
+/// func map<T, E>(_ body: (Element) throws(E) -> T) throws(E) -> [T]
+/// \endcode
+static bool isRethrowLikeTypedThrows(AbstractFunctionDecl *func) {
+  // This notion is only for compatibility in Swift 5 and is disabled
+  // when FullTypedThrows is enabled.
+  ASTContext &ctx = func->getASTContext();
+  if (ctx.LangOpts.hasFeature(Feature::FullTypedThrows))
+    return false;
+
+  // It must have a thrown error type...
+  auto thrownError = func->getThrownInterfaceType();
+  if (!thrownError)
+    return false;
+
+  /// ... that is a generic parameter type (call it E)
+  auto thrownErrorGP = thrownError->getAs<GenericTypeParamType>();
+  if (!thrownErrorGP)
+    return false;
+
+  /// ... of the generic function.
+  auto genericParams = func->getGenericParams();
+  if (!genericParams ||
+      thrownErrorGP->getDepth() !=
+          genericParams->getParams().front()->getDepth())
+    return false;
+
+  // E: Error must be the only conformance requirement on the generic parameter.
+  auto genericSig = func->getGenericSignature();
+  if (!genericSig)
+    return false;
+
+  auto requiredProtocols = genericSig->getRequiredProtocols(thrownErrorGP);
+  if (requiredProtocols.size() != 1 ||
+      requiredProtocols[0]->getKnownProtocolKind() != KnownProtocolKind::Error)
+    return false;
+
+  // Any parameters that are of throwing function type must also throw 'E'.
+  for (auto param : *func->getParameters()) {
+    auto paramTy = param->getInterfaceType();
+    if (auto paramFuncTy = paramTy->getAs<AnyFunctionType>()) {
+      if (auto paramThrownErrorTy = paramFuncTy->getEffectiveThrownErrorType())
+        if (!(*paramThrownErrorTy)->isEqual(thrownError))
+          return false;
+    }
+  }
+
+  return true;
+}
+
 /// A type expressing the result of classifying whether a call or function
 /// throws or is async.
 class Classification {
@@ -1090,7 +1143,7 @@ class ApplyClassifier {
       }
 
       // Handle rethrowing and reasync functions.
-      switch (fnRef.getPolymorphicEffectKind(kind)) {
+      switch (auto polyKind = fnRef.getPolymorphicEffectKind(kind)) {
       case PolymorphicEffectKind::ByConformance: {
         auto substitutions = fnRef.getSubstitutions();
         for (auto conformanceRef : substitutions.getConformances())
@@ -1101,6 +1154,20 @@ class ApplyClassifier {
         LLVM_FALLTHROUGH;
       }
 
+      case PolymorphicEffectKind::Always:
+        if (polyKind == PolymorphicEffectKind::ByConformance) {
+          LLVM_FALLTHROUGH;
+        } else if (RethrowsDC &&
+            fnRef.getKind() == AbstractFunction::Function &&
+            isRethrowLikeTypedThrows(fnRef.getFunction())) {
+          // If we are in a rethrowing context and the function we're referring
+          // to is a rethrow-like function using typed throws, then look at all
+          // of the closure arguments.
+          LLVM_FALLTHROUGH;
+        } else {
+          break;
+        }
+
       case PolymorphicEffectKind::ByClosure: {
         // We need to walk the original parameter types in parallel
         // because it only counts for rethrows/reasync purposes if it
@@ -1123,8 +1190,9 @@ class ApplyClassifier {
           auto argClassification = classifyArgument(
               args->getExpr(i), params[i].getParameterType(), kind);
 
-          // Rethrows is untyped, so
-          if (kind == EffectKind::Throws) {
+          // Rethrows is untyped, so adjust the thrown error type.
+          if (kind == EffectKind::Throws &&
+              polyKind == PolymorphicEffectKind::ByClosure) {
             argClassification = argClassification.promoteToUntypedThrows();
           }
 
@@ -1135,7 +1203,6 @@ class ApplyClassifier {
       }
 
       case PolymorphicEffectKind::None:
-      case PolymorphicEffectKind::Always:
       case PolymorphicEffectKind::Invalid:
         break;
       }
@@ -1282,8 +1349,15 @@ class ApplyClassifier {
     // within the rethrows context.
     if (!isLocallyDefinedInPolymorphicEffectDeclContext(fn, kind) ||
         !fn->hasBody()) {
+      auto conditional = ConditionalEffectKind::Always;
+
+      // If we are within a rethrows context prior, treat some typed-throws
+      // functions as conditionally throwing.
+      if (RethrowsDC && isRethrowLikeTypedThrows(fn))
+        conditional = ConditionalEffectKind::Conditional;
+
       return Classification::forDeclRef(
-          ConcreteDeclRef(fn, subs), ConditionalEffectKind::Always, reason)
+          ConcreteDeclRef(fn, subs), conditional, reason)
             .onlyEffect(kind);
     }
 

test/decl/func/typed_throws.swift

@@ -154,3 +154,28 @@ 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'}}
 }
+
+// Compatibility feature: calls from a rethrows function to a rethrows-like
+// function using typed throws are permitted.
+func rethrowsLike<E>(_ body: () throws(E) -> Void) throws(E) { }
+
+protocol P { }
+
+func notRethrowsLike1<E: P>(_ body: () throws(E) -> Void) throws(E) { }
+// expected-note@-1{{required by global function 'notRethrowsLike1' where 'E' = 'any Error'}}
+
+func notRethrowsLike2<E>(_ body: () throws(E) -> Void) throws { }
+func notRethrowsLike3<E>(_ body: () throws(E) -> Void, defaulted: () throws -> Void = {}) throws(E) { }
+
+func fromRethrows(body: () throws -> Void) rethrows {
+  try rethrowsLike(body)
+
+  try rethrowsLike(hasThrownMyError) // expected-error{{call can throw, but the error is not handled; a function declared 'rethrows' may only throw if its parameter does}}
+  // expected-note@-1{{call is to 'rethrows' function, but argument function can throw}}
+
+  try notRethrowsLike1(body) // expected-error{{type 'any Error' cannot conform to 'P'}}
+  // expected-note@-1{{only concrete types such as structs, enums and classes can conform to protocols}}
+
+  try notRethrowsLike2(body) // expected-error{{call can throw, but the error is not handled; a function declared 'rethrows' may only throw if its parameter does}}
+  try notRethrowsLike3(body) // expected-error{{call can throw, but the error is not handled; a function declared 'rethrows' may only throw if its parameter does}}
+}

test/stmt/typed_throws.swift

@@ -138,3 +138,11 @@ func testTryIncompatibleTyped(cond: Bool) throws(HomeworkError) {
     throw .forgot
   }
 }
+
+// "Rethrow-like" functions are only allowed to be called from rethrows
+// functions as a compatibility hack, which is removed under FullTypedThrows.
+func rethrowsLike<E>(_ body: () throws(E) -> Void) throws(E) { }
+
+func fromRethrows(body: () throws -> Void) rethrows {
+  try rethrowsLike(body) // expected-error{{call can throw, but the error is not handled; a function declared 'rethrows' may only throw if its parameter does}}
+}