[ConstraintSystem] If the contextual parameter type doesn't exist when

resolving a closure, create a new type variable for inferred property
wrapper types.

Author: hborla

lib/Sema/CSSimplify.cpp

@@ -8682,8 +8682,18 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
       Type wrappedValueType;
 
       if (paramDecl->hasImplicitPropertyWrapper()) {
-        backingType = getContextualParamAt(i)->getPlainType();
-        wrappedValueType = createTypeVariable(getConstraintLocator(locator),
+        if (auto contextualType = getContextualParamAt(i)) {
+          backingType = contextualType->getPlainType();
+        } else {
+          // There may not be a contextual parameter type if the contextual
+          // type is not a function type or if closure body declares too many
+          // parameters.
+          auto *paramLoc =
+              getConstraintLocator(closure, LocatorPathElt::TupleElement(i));
+          backingType = createTypeVariable(paramLoc, TVO_CanBindToHole);
+        }
+
+        wrappedValueType = createTypeVariable(getConstraintLocator(paramDecl),
                                               TVO_CanBindToHole | TVO_CanBindToLValue);
       } else {
         auto *wrapperAttr = paramDecl->getAttachedPropertyWrappers().front();

test/Sema/property_wrapper_parameter_invalid.swift

@@ -205,3 +205,32 @@ struct OptionalWrapper<Value> { // expected-note {{'Value' declared as parameter
 // expected-error@+2 {{generic parameter 'Value' could not be inferred}} expected-note@+2 {{}}
 // expected-error@+1 {{property type 'Int' does not match 'wrappedValue' type 'Value?'}}
 func testWrappedValueMismatch(@OptionalWrapper value: Int) {}
+
+@propertyWrapper
+struct ProjectionWrapper<Value> {
+  var wrappedValue: Value
+  var projectedValue: Self { self }
+  init(projectedValue: Self) { self = projectedValue }
+}
+
+func testInvalidWrapperInference() {
+  struct S<V> {
+    static func test(_ keyPath: KeyPath<V, String>) {} // expected-note {{'test' declared here}}
+  }
+
+  // expected-error@+1 {{trailing closure passed to parameter of type 'KeyPath<Int, String>' that does not accept a closure}}
+  S<Int>.test { $value in }
+  // expected-error@+1 {{cannot convert value of type '(_) -> ()' to expected argument type 'KeyPath<Int, String>'}}
+  S<Int>.test({ $value in })
+
+  func testGenericClosure<T>(_ closure: T) {}
+  // FIXME: the following error should use the name of the closure parameter.
+  // It's not anonymous, even though it starts with $
+  // expected-error@+1 {{unable to infer type of a closure parameter $0 in the current context}}
+  testGenericClosure { $value in }
+  testGenericClosure { ($value: ProjectionWrapper<Int>) in } // okay
+
+  func testExtraParameter(_ closure: () -> Void) {}
+  // expected-error@+1 {{contextual closure type '() -> Void' expects 0 arguments, but 1 was used in closure body}}
+  testExtraParameter { $value in }
+}