Sema: Fix inconsistent rethrows conformance checking with 'self' parameter

Author: slavapestov

lib/Sema/TypeCheckEffects.cpp

@@ -169,19 +169,28 @@ FunctionRethrowingKindRequest::evaluate(Evaluator &evaluator,
       return FunctionRethrowingKind::ByConformance;
     }
     if (markedRethrows) {
-      GenericSignature genericSig = decl->getGenericSignature();
-      FunctionRethrowingKind kind = getParameterThrowingKind(decl, genericSig);
-      // since we have checked all arguments, if we still havent found anything
-      // check the self parameter
-      if (kind == FunctionRethrowingKind::Invalid && 
-          decl->hasImplicitSelfDecl()) {
-        auto selfParam = decl->getImplicitSelfDecl();
-        if (selfParam) {
-          auto interfaceTy = selfParam->getInterfaceType();
-          kind = getTypeThrowingKind(interfaceTy, genericSig);
+      if (auto genericSig = decl->getGenericSignature()) {
+        for (auto req : genericSig->getRequirements()) {
+          if (req.getKind() == RequirementKind::Conformance) {
+            if (req.getSecondType()->castTo<ProtocolType>()
+                                   ->getDecl()
+                                   ->isRethrowingProtocol()) {
+              return FunctionRethrowingKind::ByConformance;
+            }
+          }
         }
       }
-      return kind;
+
+      for (auto param : *decl->getParameters()) {
+        auto interfaceTy = param->getInterfaceType();
+        if (hasThrowingFunctionClosureParameter(interfaceTy
+              ->lookThroughAllOptionalTypes()
+              ->getCanonicalType())) {
+          return FunctionRethrowingKind::ByClosure;
+        }
+      }
+
+      return FunctionRethrowingKind::Invalid;
     }
     return FunctionRethrowingKind::Throws;
   }

test/attr/attr_rethrows_protocol.swift

@@ -39,7 +39,9 @@ struct InvalidRethrows : InvalidRethrowingProtocol {
 
 func freeFloatingRethrowing<R: RethrowingProtocol>(_ r: R) rethrows { }
 
-func freeFloatingRethrowingFromExistential(_ r: RethrowingProtocol) rethrows { }
+func freeFloatingRethrowingFromExistential(_ r: RethrowingProtocol) rethrows {
+  // expected-error@-1{{'rethrows' function must take a throwing function argument}}
+}
 
 func invalidFreeFloatingRethrows() rethrows {
   // expected-error@-1{{'rethrows' function must take a throwing function argument}}
@@ -68,11 +70,30 @@ func freeFloatingRethrowing<R: HasAssociatedRethrower>(_ r: R) rethrows { }
 protocol InheritsRethrowing: RethrowingProtocol {}
 
 func freeFloatingInheritedRethrowingFunction<I: InheritsRethrowing>(_ r: I) rethrows { }
-func freeFloatingInheritedRethrowingFunctionFromExistential(_ r: InheritsRethrowing) rethrows { }
+
+func freeFloatingInheritedRethrowingFunctionFromExistential(_ r: InheritsRethrowing) rethrows {
+  // expected-error@-1{{'rethrows' function must take a throwing function argument}}
+}
 
 func closureAndRethrowing<R: RethrowingProtocol>(_ r: R, _ closure: () throws -> Void) rethrows { }
 
 closureAndRethrowing(NonThrows()) { }
 try closureAndRethrowing(NonThrows()) { } // expected-warning{{no calls to throwing functions occur within 'try' expression}}
 try closureAndRethrowing(Throws()) { }
 try closureAndRethrowing(NonThrows()) { () throws -> Void in }
+
+// Make sure we handle the case where both the 'self' parameter and a closure
+// argument are rethrows sources.
+extension RethrowingProtocol {
+  func selfRethrowing() rethrows { }
+  func closureAndSelfRethrowing(_ closure: () throws -> Void) rethrows { }
+}
+
+NonThrows().selfRethrowing()
+try Throws().selfRethrowing()
+
+NonThrows().closureAndSelfRethrowing { }
+try NonThrows().closureAndSelfRethrowing { () throws -> Void in }
+
+try Throws().closureAndSelfRethrowing { }
+try Throws().closureAndSelfRethrowing { () throws -> Void in }