[Typed throws] Handle key-path literal used with a function that has typed throws

When providing a key-path literal for a parameter of function type
where that function type has a generic parameter for its thrown error
type, infer `Never` for the generic argument because key paths don't
throw.

Thanks to @xedin for realizing that this would be an issue.

Author: DougGregor

lib/Sema/CSSimplify.cpp

@@ -12248,6 +12248,16 @@ ConstraintSystem::simplifyKeyPathConstraint(
       // { root in root[keyPath: kp] }.
       boundRoot = fnTy->getParams()[0].getParameterType();
       boundValue = fnTy->getResult();
+
+      // Key paths never throw, so if the function has a thrown error type
+      // that is a type variable, infer it to be Never.
+      if (auto thrownError = fnTy->getThrownError()) {
+        if (thrownError->isTypeVariableOrMember()) {
+          (void)matchTypes(
+            thrownError, getASTContext().getNeverType(),
+            ConstraintKind::Equal, TMF_GenerateConstraints, locator);
+        }
+      }
     }
 
     if (boundRoot &&

test/decl/func/typed_throws.swift

@@ -76,10 +76,14 @@ func mapArray<T, U, E: Error>(_ array: [T], body: (T) throws(E) -> U) throws(E)
   return resultArray
 }
 
+struct Person {
+  var name: String
+}
+
 func addOrThrowUntyped(_ i: Int, _ j: Int) throws -> Int { i + j }
 func addOrThrowMyError(_ i: Int, _ j: Int) throws(MyError) -> Int { i + j }
 
-func testMapArray(numbers: [Int]) {
+func testMapArray(numbers: [Int], friends: [Person]) {
   // Note: try is not required, because this throws Never
   _ = mapArray(numbers) { $0 + 1 }
 
@@ -101,6 +105,11 @@ func testMapArray(numbers: [Int]) {
   } catch {
     let _: Int = error // expected-error{{cannot convert value of type 'MyError' to specified type 'Int'}}
   }
+
+  do {
+    // Keypath-as-function
+    _ = mapArray(friends, body: \Person.name)
+  }
 }
 
 // Inference of Error conformance from the use of a generic parameter in typed