[CSSimplify] Start checking whether result type of a call needs a coercion

If there is going to be any loss of generic requirements in the result,
a result of a call has to use explicit coercion.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -11449,6 +11449,18 @@ ConstraintSystem::simplifyApplicableFnConstraint(
             result2, opened.second->getExistentialType(), opened.first,
             TypePosition::Covariant);
       }
+
+      // If result type has any erased existential types it requires explicit
+      // `as` coercion.
+      if (AddExplicitExistentialCoercion::isRequired(
+              *this, func2->getResult(), openedExistentials, locator)) {
+        if (!shouldAttemptFixes())
+          return SolutionKind::Error;
+
+        if (recordFix(AddExplicitExistentialCoercion::create(
+                *this, result2, getConstraintLocator(locator))))
+          return SolutionKind::Error;
+      }
     }
 
     // The result types are equivalent.

test/Constraints/opened_existentials.swift

@@ -210,3 +210,32 @@ func testTakeValueAndClosure(p: any P) {
     // expected-note@-1{{did you mean to use 'as!' to force downcast?}}
     p)
 }
+
+protocol B {
+  associatedtype C: P where C.A == Double
+}
+
+func testExplicitCoercionRequirement(v: any B) {
+  func getC<T: B>(_: T) -> T.C { fatalError() }
+  func getTuple<T: B>(_: T) -> (T, T.C) { fatalError() }
+  func getNoError<T: B>(_: T) -> T.C.A { fatalError() }
+  func getComplex<T: B>(_: T) -> ([(x: (a: T.C, b: Int), y: Int)], [Int: T.C]) { fatalError() }
+
+  func overloaded<T: B>(_: T) -> (x: Int, y: T.C) { fatalError() }
+  // expected-note@-1 {{inferred result type '(x: Int, y: any P)' requires explicit coercion due to loss of generic requirements}} {{240:20-20=as (x: Int, y: any P)}}
+  func overloaded<T: P>(_: T) -> Int { 42 }
+  // expected-note@-1 {{candidate requires that 'any B' conform to 'P' (requirement specified as 'T' : 'P')}}
+
+  _ = getC(v) // expected-error {{inferred result type 'any P' requires explicit coercion due to loss of generic requirements}} {{14-14=as any P}}
+  _ = getC(v) as any P // Ok
+
+  _ = getTuple(v) // expected-error {{inferred result type '(any B, any P)' requires explicit coercion due to loss of generic requirements}} {{18-18=as (any B, any P)}}
+  _ = getTuple(v) as (any B, any P) // Ok
+
+  _ = getNoError(v) // Ok because T.C.A == Double
+
+  _ = getComplex(v) // expected-error {{inferred result type '([(x: (a: any P, b: Int), y: Int)], [Int : any P])' requires explicit coercion due to loss of generic requirements}} {{20-20=as ([(x: (a: any P, b: Int), y: Int)], [Int : any P])}}
+  _ = getComplex(v) as ([(x: (a: any P, b: Int), y: Int)], [Int : any P]) // Ok
+
+  _ = overloaded(v) // expected-error {{no exact matches in call to local function 'overloaded'}}
+}