[CS] Correctly handle compound-applied functions with property wrappers

Avoid wrapping parameters in the function reference
for compound applies, and make sure we consult
the parameter label in the compound name if it's
present to determine whether to match using the
projected value or not. This matches the existing
logic in `unwrapPropertyWrapperParameterTypes`.

Author: hamishknight

lib/Sema/CSApply.cpp

@@ -764,10 +764,7 @@ namespace {
 
       if (auto *fnDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
         if (AnyFunctionRef(fnDecl).hasExternalPropertyWrapperParameters() &&
-            // FIXME(FunctionRefInfo): This should just be `isUnapplied()`, see
-            // the FIXME in `unwrapPropertyWrapperParameterTypes`.
-            (declRefExpr->getFunctionRefInfo().isCompoundName() ||
-             declRefExpr->getFunctionRefInfo().isUnappliedBaseName())) {
+            declRefExpr->getFunctionRefInfo().isUnapplied()) {
           // We don't need to do any further adjustment once we've built the
           // curry thunk.
           return buildSingleCurryThunk(result, fnDecl,

lib/Sema/CSSimplify.cpp

@@ -1725,6 +1725,17 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
       continue;
     }
 
+    // See if we have a parameter label specified in the function's DeclNameLoc.
+    Identifier compoundParamLabel;
+    if (auto *E = getAsExpr(calleeLocator->getAnchor())) {
+      auto nameLoc = E->getNameLoc();
+      if (auto labelLoc = nameLoc.getArgumentLabelLoc(paramIdx)) {
+        auto &ctx = cs.getASTContext();
+        auto labelTok = Lexer::getTokenAtLocation(ctx.SourceMgr, labelLoc);
+        compoundParamLabel = ctx.getIdentifier(labelTok.getText());
+      }
+    }
+
     // Compare each of the bound arguments for this parameter.
     for (auto argIdx : parameterBindings[paramIdx]) {
       auto loc = locator.withPathElement(LocatorPathElt::ApplyArgToParam(
@@ -1813,14 +1824,17 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
         openedExistentials.push_back({openedTypeVar, opened});
       }
 
-      auto argLabel = argument.getLabel();
+      // If we have a compound function reference (e.g `fn($x:)`), respect
+      // the parameter label given. Otherwise look at the argument label.
+      auto wrapperArgLabel = compoundParamLabel.empty() ? argument.getLabel()
+                                                        : compoundParamLabel;
       if (paramInfo.hasExternalPropertyWrapper(paramIdx) ||
-          argLabel.hasDollarPrefix()) {
+          wrapperArgLabel.hasDollarPrefix()) {
         auto *param = getParameterAt(callee, paramIdx);
         assert(param);
         if (cs.applyPropertyWrapperToParameter(paramTy, argTy,
                                                const_cast<ParamDecl *>(param),
-                                               argLabel, subKind, loc)
+                                               wrapperArgLabel, subKind, loc)
                 .isFailure()) {
           return cs.getTypeMatchFailure(loc);
         }

lib/Sema/TypeOfReference.cpp

@@ -686,13 +686,8 @@ unwrapPropertyWrapperParameterTypes(ConstraintSystem &cs, AbstractFunctionDecl *
                                     FunctionRefInfo functionRefInfo, FunctionType *functionType,
                                     ConstraintLocatorBuilder locator) {
   // Only apply property wrappers to unapplied references to functions.
-  // FIXME(FunctionRefInfo): This should just be `isUnapplied()`, which would
-  // fix https://github.com/swiftlang/swift/issues/77823, but we also need to
-  // correctly handle the wrapping in matchCallArguments.
-  if (!(functionRefInfo.isCompoundName() ||
-        functionRefInfo.isUnappliedBaseName())) {
+  if (!functionRefInfo.isUnapplied())
     return functionType;
-  }
 
   // This transform is not applicable to pattern matching context.
   //

test/Sema/property_wrapper_parameter.swift

@@ -159,6 +159,40 @@ struct ProjectionWrapper<Value> {
   }
 }
 
+// https://github.com/swiftlang/swift/issues/77823
+// Make sure we correctly handle compound applied functions.
+func testCompoundApplication() {
+  func foo(@ProjectionWrapper x: Int) {}
+  struct HasProjectionWrapperMember {
+    static func foo(@ProjectionWrapper x: Int) {}
+  }
+
+  foo(x:)(0)
+  foo($x:)(ProjectionWrapper(wrappedValue: 0))
+
+  (foo($x:).self)(ProjectionWrapper(wrappedValue: 0))
+  HasProjectionWrapperMember.foo($x:)(ProjectionWrapper(wrappedValue: 0))
+
+  foo(x:)(ProjectionWrapper(wrappedValue: 0)) // expected-error {{cannot convert value of type 'ProjectionWrapper<Int>' to expected argument type 'Int'}}
+  foo(x:)(ProjectionWrapper(wrappedValue: "")) // expected-error {{cannot convert value of type 'ProjectionWrapper<String>' to expected argument type 'Int'}}
+  foo(x:)("") // expected-error {{cannot convert value of type 'String' to expected argument type 'Int'}}
+
+  foo($x:)(ProjectionWrapper(wrappedValue: "")) // expected-error {{cannot convert value of type 'String' to expected argument type 'Int'}}
+  foo($x:)(0) // expected-error {{cannot convert value of type 'Int' to expected argument type 'ProjectionWrapper<Int>'}}
+  foo($x:)("") // expected-error {{cannot convert value of type 'String' to expected argument type 'ProjectionWrapper<Int>'}}
+
+  func bar(x: Int) {} // expected-note 2{{parameter 'x' does not have an attached property wrapper}}
+  bar($x:)(0) // expected-error {{cannot use property wrapper projection argument}}
+  _ = bar($x:) // expected-error {{cannot use property wrapper projection argument}}
+
+  func baz(@ProjectionWrapper x: Int, @ProjectionWrapper y: Int) {}
+  baz($x:y:)(ProjectionWrapper(wrappedValue: 0), 0)
+  baz(x:$y:)(0, ProjectionWrapper(wrappedValue: 0))
+
+  let _: (ProjectionWrapper<Int>, Int) -> Void = baz($x:y:)
+  let _: (Int, ProjectionWrapper<Int>) -> Void = baz(x:$y:)
+}
+
 func testImplicitPropertyWrapper() {
   typealias PropertyWrapperTuple = (ProjectionWrapper<Int>, Int, ProjectionWrapper<Int>)