Generalize inference of Error type requirements from typed throws

Author: DougGregor

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -849,8 +849,11 @@ InferredGenericSignatureRequest::evaluate(
   // Finish by adding any remaining requirements. This is used to introduce
   // inferred same-type requirements when building the generic signature of
   // an extension whose extended type is a generic typealias.
+  SmallVector<Requirement, 4> rawAddedRequirements;
   for (const auto &req : addedRequirements)
-    requirements.push_back({req, SourceLoc(), /*wasInferred=*/true});
+    desugarRequirement(req, SourceLoc(), rawAddedRequirements, errors);
+  for (const auto &req : rawAddedRequirements)
+    requirements.push_back({req, SourceLoc(), /*inferred=*/true});
 
   // Re-order requirements so that inferred requirements appear last. This
   // ensures that if an inferred requirement is redundant with some other

lib/Sema/TypeCheckGeneric.cpp

@@ -768,12 +768,10 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
           inferenceSources.emplace_back(thrownTypeRepr, thrownType);
 
           // Add conformance of this type to the Error protocol.
-          if (thrownType->isTypeParameter()) {
-            if (auto errorProtocol = ctx.getErrorDecl()) {
-              extraReqs.push_back(
-                  Requirement(RequirementKind::Conformance, thrownType,
-                              errorProtocol->getDeclaredInterfaceType()));
-            }
+          if (auto errorProtocol = ctx.getErrorDecl()) {
+            extraReqs.push_back(
+                Requirement(RequirementKind::Conformance, thrownType,
+                            errorProtocol->getDeclaredInterfaceType()));
           }
         }
       }

test/decl/func/typed_throws.swift

@@ -135,3 +135,14 @@ struct HasASubscript {
 
 // expected-error@+1{{thrown type 'any Codable & Error' (aka 'any Decodable & Encodable & Error') does not conform to the 'Error' protocol}}
 func throwCodableErrors() throws(any Codable & Error) { }
+
+enum Either<First, Second> {
+case first(First)
+case second(Second)
+}
+
+extension Either: Error where First: Error, Second: Error { }
+
+func f<E1, E2>(_ error: Either<E1, E2>) throws(Either<E1, E2>) {
+  throw error
+}