Don't open an existential call argument if its type information is needed earlier.

To ensure that we do not accept code that would require an existential call argument
to be evaluated prior to the call, don't open existential call
arguments if the generic parameter that would capture the opened
existential type is used in any prior parameter.

Note that code generation currently moves the opening of the
existential call argument outside of the call, which is a compiler bug.
This change ensures that we don't accept code would *require* this
out-of-order evaluation and adds a test so we know when we fix this.

Author: DougGregor

lib/AST/Decl.cpp

@@ -4048,9 +4048,16 @@ GenericParameterReferenceInfo swift::findGenericParameterReferences(
             sig, genericParam, param.getPlainType(), TypePosition::Invariant);
         continue;
       }
+
+      // Parameters are contravariant, but if we're prior to the skipped
+      // parameter treat them as invariant because we're not allowed to
+      // reference the parameter at all.
+      TypePosition position = TypePosition::Contravariant;
+      if (skipParamIndex && paramIdx < *skipParamIndex)
+        position = TypePosition::Invariant;
+
       inputInfo |= ::findGenericParameterReferences(
-          sig, genericParam, param.getParameterType(),
-          TypePosition::Contravariant);
+          sig, genericParam, param.getParameterType(), position);
     }
 
     // A covariant Self result inside a parameter will not be bona fide.

test/Constraints/opened_existentials.swift

@@ -181,6 +181,8 @@ func testReturningOpaqueTypes(p: any P) {
 
 // Type-erasing vs. opening for parameters after the opened one.
 func takeValueAndClosure<T: P>(_ value: T, body: (T) -> Void) { }
+func takeValueAndClosureBackwards<T: P>(body: (T) -> Void, _ value: T) { }
+// expected-note@-1{{required by global function 'takeValueAndClosureBackwards(body:_:)' where 'T' = 'any P'}}
 
 func genericFunctionTakingP<T: P>(_: T) { }
 func genericFunctionTakingPQ<T: P & Q>(_: T) { }
@@ -199,4 +201,12 @@ func testTakeValueAndClosure(p: any P) {
   takeValueAndClosure(p, body: genericFunctionTakingP)
   takeValueAndClosure(p, body: overloadedGenericFunctionTakingP)
   takeValueAndClosure(p, body: genericFunctionTakingPQ) // expected-error{{global function 'genericFunctionTakingPQ' requires that 'T' conform to 'Q'}}
+
+  // Do not allow opening if there are any uses of the the type parameter before
+  // the opened parameter. This maintains left-to-right evaluation order.
+  takeValueAndClosureBackwards( // expected-error{{type 'any P' cannot conform to 'P'}}
+    // expected-note@-1{{only concrete types such as structs, enums and classes can conform to protocols}}
+    body: { x in x as Int }, // expected-error{{'any P' is not convertible to 'Int'}}
+    // expected-note@-1{{did you mean to use 'as!' to force downcast?}}
+    p)
 }

test/SILGen/opened_existentials.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-emit-silgen -enable-experimental-opened-existential-types %s | %FileCheck %s
+
+public protocol P { }
+
+func f() -> String {
+  print("f()")
+  return "Hello"
+}
+
+func g<T: P> (_ value: String, _: T) -> String {
+  print("g()")
+  return value + ", world"
+}
+
+extension Int: P { }
+
+func getP() -> any P {
+  return 17
+}
+
+// CHECK: sil [ossa] @$s19opened_existentials4testSSyF : $@convention(thin) () -> @owned String
+public func test() -> String {
+  // FIXME: This demonstrates that we are opening the existential out of
+  // order. This test will break when we properly update the existential-opening
+  // logic to wait until the argument is evaluated.
+
+  // CHECK: [[PSTACK:%.*]] = alloc_stack $P
+  // CHECK: [[GETP:%.*]] = function_ref @$s19opened_existentials4getPAA1P_pyF : $@convention(thin) () -> @out P // user: %2
+  // CHECK: [[P:%.*]] = apply [[GETP]]([[PSTACK]]) : $@convention(thin) () -> @out P
+  // CHECK: [[OPENEDP:%.*]] = open_existential_addr immutable_access [[PSTACK]] : $*P to $*@opened
+  // CHECK: [[F:%.*]] = function_ref @$s19opened_existentials1fSSyF : $@convention(thin) () -> @owned String
+  // CHECK: [[F_RESULT:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned String
+  g(f(), getP())
+}
+