Merge pull request #37380 from hborla/property-wrapper-inference-crash

[ConstraintSystem] Fix a constraint system crash with property wrapper inference using the $ syntax.

Author: hborla

lib/Sema/CSDiagnostics.cpp

@@ -6819,13 +6819,9 @@ bool UnableToInferClosureParameterType::diagnoseAsError() {
   llvm::SmallString<16> id;
   llvm::raw_svector_ostream OS(id);
 
-  if (PD->isAnonClosureParam()) {
-    OS << "$" << paramIdx;
-  } else {
-    OS << "'" << PD->getParameterName() << "'";
-  }
+  OS << "'" << PD->getParameterName() << "'";
 
-  auto loc = PD->isAnonClosureParam() ? getLoc() : PD->getLoc();
+  auto loc = PD->isImplicit() ? getLoc() : PD->getLoc();
   emitDiagnosticAt(loc, diag::cannot_infer_closure_parameter_type, OS.str());
   return true;
 }

lib/Sema/CSFix.cpp

@@ -1545,11 +1545,7 @@ std::string SpecifyClosureParameterType::getName() const {
   auto *PD = closure->getParameters()->get(paramLoc.getIndex());
 
   OS << "specify type for parameter ";
-  if (PD->isAnonClosureParam()) {
-    OS << "$" << paramLoc.getIndex();
-  } else {
-    OS << "'" << PD->getParameterName() << "'";
-  }
+  OS << "'" << PD->getParameterName() << "'";
 
   return OS.str();
 }

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/Constraints/closures.swift

@@ -499,7 +499,7 @@ struct S_3520 {
 func sr3520_set_via_closure<S, T>(_ closure: (inout S, T) -> ()) {} // expected-note {{in call to function 'sr3520_set_via_closure'}}
 sr3520_set_via_closure({ $0.number1 = $1 })
 // expected-error@-1 {{generic parameter 'S' could not be inferred}}
-// expected-error@-2 {{unable to infer type of a closure parameter $1 in the current context}}
+// expected-error@-2 {{unable to infer type of a closure parameter '$1' in the current context}}
 
 // SR-3073: UnresolvedDotExpr in single expression closure
 

test/Constraints/diagnostics.swift

@@ -296,7 +296,7 @@ func r18800223(_ i : Int) {
 }
 
 // <rdar://problem/21883806> Bogus "'_' can only appear in a pattern or on the left side of an assignment" is back
-_ = { $0 }  // expected-error {{unable to infer type of a closure parameter $0 in the current context}}
+_ = { $0 }  // expected-error {{unable to infer type of a closure parameter '$0' in the current context}}
 
 
 

test/Constraints/one_way_closure_params.swift

@@ -3,6 +3,6 @@
 func testBasic() {
   let _: (Float) -> Float = { $0 + 1 }
 
-  let _ = { $0 + 1 } // expected-error{{unable to infer type of a closure parameter $0 in the current context}}
+  let _ = { $0 + 1 } // expected-error{{unable to infer type of a closure parameter '$0' in the current context}}
 }
 

test/Sema/property_wrapper_parameter_invalid.swift

@@ -205,3 +205,30 @@ 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) {}
+  // expected-error@+1 {{unable to infer type of a closure parameter '$value' 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 }
+}

test/expr/closure/anonymous.swift

@@ -32,7 +32,7 @@ func variadic() {
   // FIXME: Problem here is related to multi-statement closure body not being type-checked together with
   // enclosing context. We could have inferred `$0` to be `[Int]` if `let` was a part of constraint system.
   takesVariadicGeneric({let _: [Int] = $0})
-  // expected-error@-1 {{unable to infer type of a closure parameter $0 in the current context}}
+  // expected-error@-1 {{unable to infer type of a closure parameter '$0' in the current context}}
 
   takesVariadicIntInt({_ = $0; takesIntArray($1)})
   takesVariadicIntInt({_ = $0; let _: [Int] = $1})