Allow explicit "as <existential-type>" to disable implicit opening of existentials

Author: DougGregor

lib/Sema/CSSimplify.cpp

@@ -1348,7 +1348,8 @@ namespace {
 static Optional<
     std::tuple<TypeVariableType *, Type, OpenedExistentialAdjustments>>
 shouldOpenExistentialCallArgument(
-    ValueDecl *callee, unsigned paramIdx, Type paramTy, Type argTy) {
+    ValueDecl *callee, unsigned paramIdx, Type paramTy, Type argTy,
+    Expr *argExpr, ConstraintSystem &cs) {
   if (!callee)
     return None;
 
@@ -1382,6 +1383,20 @@ shouldOpenExistentialCallArgument(
   if (!paramTy->hasTypeVariable())
     return None;
 
+  // An argument expression that explicitly coerces to an existential
+  // disables the implicit opening of the existential.
+  if (argExpr) {
+    if (auto argCoercion = dyn_cast<CoerceExpr>(
+            argExpr->getSemanticsProvidingExpr())) {
+      if (auto typeRepr = argCoercion->getCastTypeRepr()) {
+        if (auto toType = cs.getType(typeRepr)) {
+          if (toType->isAnyExistentialType())
+            return None;
+        }
+      }
+    }
+  }
+
   OpenedExistentialAdjustments adjustments;
 
   // If the argument is inout, strip it off and we can add it back.
@@ -1670,10 +1685,10 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
       auto argTy = argument.getOldType();
 
       bool matchingAutoClosureResult = param.isAutoClosure();
+      auto *argExpr = getArgumentExpr(locator.getAnchor(), argIdx);
       if (param.isAutoClosure() && !isSynthesizedArgument(argument)) {
         auto &ctx = cs.getASTContext();
         auto *fnType = paramTy->castTo<FunctionType>();
-        auto *argExpr = getArgumentExpr(locator.getAnchor(), argIdx);
 
         // If this is a call to a function with a closure argument and the
         // parameter is an autoclosure, let's just increment the score here
@@ -1715,7 +1730,7 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
       // If the argument is an existential type and the parameter is generic,
       // consider opening the existential type.
       if (auto existentialArg = shouldOpenExistentialCallArgument(
-              callee, paramIdx, paramTy, argTy)) {
+              callee, paramIdx, paramTy, argTy, argExpr, cs)) {
         // My kingdom for a decent "if let" in C++.
         TypeVariableType *openedTypeVar;
         Type existentialType;

test/Constraints/opened_existentials_suppression.swift

@@ -0,0 +1,11 @@
+// RUN: %target-swift-frontend -enable-experimental-opened-existential-types -typecheck -dump-ast -parse-as-library %s | %FileCheck %s
+
+protocol P { }
+
+func acceptsBox<T>(_ value: T) { }
+
+// CHECK: passBox
+// CHECK-NOT: open_existential_expr
+func passBox(p: P) {
+  acceptsBox(p as P)
+}