Drop throws(any Error) and throws(Never) sugar after substitution

When substitution into a function type with `throws(E)` produces either
`throws(any Error)` or `throws(Never)`, adjust the resulting function
type to the equivalent `throws` or non-throwing.

Author: DougGregor

lib/AST/Type.cpp

@@ -5065,6 +5065,28 @@ case TypeKind::Id:
         isUnchanged = false;
     }
 
+    llvm::Optional<ASTExtInfo> extInfo;
+    if (function->hasExtInfo()) {
+      extInfo = function->getExtInfo()
+                    .withGlobalActor(globalActorType)
+                    .withThrows(function->isThrowing(), thrownError);
+
+      // If there was a generic thrown error and it substituted with
+      // 'any Error' or 'Never', map to 'throws' or non-throwing rather than
+      // maintaining the sugar.
+      if (auto origThrownError = function->getThrownError()) {
+        if (origThrownError->isTypeParameter() ||
+            origThrownError->isTypeVariableOrMember()) {
+          // 'any Error'
+          if (thrownError->isEqual(
+                  thrownError->getASTContext().getErrorExistentialType()))
+            extInfo = extInfo->withThrows(true, Type());
+          else if (thrownError->isNever())
+            extInfo = extInfo->withThrows(false, Type());
+        }
+      }
+    }
+
     if (auto genericFnType = dyn_cast<GenericFunctionType>(base)) {
 #ifndef NDEBUG
       // Check that generic parameters won't be transformed.
@@ -5080,24 +5102,13 @@ case TypeKind::Id:
       if (isUnchanged) return *this;
 
       auto genericSig = genericFnType->getGenericSignature();
-      if (!function->hasExtInfo())
-        return GenericFunctionType::get(genericSig, substParams, resultTy);
       return GenericFunctionType::get(
-               genericSig, substParams, resultTy,
-               function->getExtInfo()
-                 .withGlobalActor(globalActorType)
-                 .withThrows(function->isThrowing(), thrownError));
+          genericSig, substParams, resultTy, extInfo);
     }
 
     if (isUnchanged) return *this;
 
-    if (!function->hasExtInfo())
-      return FunctionType::get(substParams, resultTy);
-    return FunctionType::get(
-             substParams, resultTy,
-             function->getExtInfo()
-               .withGlobalActor(globalActorType)
-               .withThrows(function->isThrowing(), thrownError));
+    return FunctionType::get(substParams, resultTy, extInfo);
   }
 
   case TypeKind::ArraySlice: {

test/decl/func/typed_throws.swift

@@ -179,3 +179,14 @@ func fromRethrows(body: () throws -> Void) rethrows {
   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}}
 }
+
+// Substitution involving 'any Error' or 'Never' thrown error types should
+// use untyped throws or be non-throwing.
+enum G_E<T> {
+  case tuple((x: T, y: T))
+}
+
+func testArrMap(arr: [String]) {
+  _ = mapArray(arr, body: G_E<Int>.tuple)
+  // expected-error@-1{{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(String) -> G_E<Int>'}}
+}