[Diagnostics] Prevent fix-it for explicit existential erasure from suppressing opening at use site

If erased result is passed as an argument to a call that requires
implicit opening, the fix-it should use parens to avoid suppressing
the opening at that argument position.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -8158,9 +8158,39 @@ bool MissingExplicitExistentialCoercion::diagnoseAsNote() {
   return true;
 }
 
+bool MissingExplicitExistentialCoercion::fixItRequiresParens() const {
+  auto anchor = getAsExpr(getRawAnchor());
+
+  // If it's a member reference an an existential metatype, let's
+  // use the parent "call" expression.
+  if (auto *UDE = dyn_cast_or_null<UnresolvedDotExpr>(anchor))
+    anchor = findParentExpr(UDE);
+
+  if (!anchor)
+    return false;
+
+  const auto &solution = getSolution();
+  return llvm::any_of(
+      solution.OpenedExistentialTypes,
+      [&anchor](const auto &openedExistential) {
+        if (auto openedLoc = simplifyLocatorToAnchor(openedExistential.first)) {
+          return anchor == getAsExpr(openedLoc);
+        }
+        return false;
+      });
+}
+
 void MissingExplicitExistentialCoercion::fixIt(
     InFlightDiagnostic &diagnostic) const {
+  bool requiresParens = fixItRequiresParens();
+
+  auto callRange = getSourceRange();
+
+  if (requiresParens)
+    diagnostic.fixItInsert(callRange.Start, "(");
+
   auto printOpts = PrintOptions::forDiagnosticArguments();
-  diagnostic.fixItInsertAfter(getSourceRange().End,
-                              "as " + ErasedResultType->getString(printOpts));
+  diagnostic.fixItInsertAfter(callRange.End,
+                              "as " + ErasedResultType->getString(printOpts) +
+                                  (requiresParens ? ")" : ""));
 }

lib/Sema/CSDiagnostics.h

@@ -2755,6 +2755,13 @@ class MissingExplicitExistentialCoercion final : public FailureDiagnostic {
 
 private:
   void fixIt(InFlightDiagnostic &diagnostic) const;
+
+  /// Determine whether the fix-it to add `as any ...` requires parens.
+  ///
+  /// Parens are required to avoid suppressing existential opening
+  /// if result of the call is passed as an argument to another call
+  /// that requires such opening.
+  bool fixItRequiresParens() const;
 };
 
 } // end namespace constraints

test/Constraints/opened_existentials.swift

@@ -283,4 +283,8 @@ func testExplicitCoercionRequirement(v: any B, otherV: any B & D) {
   func getBDSelf<T: D>(_: T) -> T { fatalError() }
   _ = getBDSelf(otherV) // expected-error {{inferred result type 'any B & D' requires explicit coercion due to loss of generic requirements}} {{24-24=as any B & D}}
   _ = getBDSelf(otherV) as any B & D // Ok
+
+  func getP<T: P>(_: T) {}
+  getP(getC(v)) // expected-error {{inferred result type 'any P' requires explicit coercion due to loss of generic requirements}} {{8-8=(}} {{15-15=as any P)}}
+  getP(v.getC()) // expected-error {{inferred result type 'any P' requires explicit coercion due to loss of generic requirements}}  {{8-8=(}} {{14-14=as any P)}}
 }