[ConstraintSystem] Don't allow dollar prefixes in argument labels unless

the parameter has an attached property wrapper.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5490,6 +5490,10 @@ NOTE(property_wrapper_declared_here,none,
 ERROR(property_wrapper_param_no_projection,none,
       "cannot use property wrapper projection parameter; "
       "wrapper %0 does not have a 'projectedValue'", (Type))
+ERROR(property_wrapper_param_no_wrapper,none,
+      "cannot use property wrapper projection argument; "
+      "parameter does not have an attached property wrapper",
+      ())
 ERROR(property_wrapper_param_projection_invalid,none,
       "cannot use property wrapper projection argument; "
       "pass wrapped value type %0 instead", (Type))

lib/Sema/CSDiagnostics.cpp

@@ -3310,10 +3310,14 @@ bool MissingProjectedValueFailure::diagnoseAsError() {
 }
 
 bool MissingPropertyWrapperAttributeFailure::diagnoseAsError() {
-  emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
+  if (auto *param = getAsDecl<ParamDecl>(getAnchor())) {
+    emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
 
-  // FIXME: emit a note and fix-it to add '@propertyWrapper' if the
-  // type is a nominal and in the same module.
+    // FIXME: emit a note and fix-it to add '@propertyWrapper' if the
+    // type is a nominal and in the same module.
+  } else {
+    emitDiagnostic(diag::property_wrapper_param_no_wrapper);
+  }
 
   return true;
 }

lib/Sema/CSGen.cpp

@@ -4061,6 +4061,18 @@ ConstraintSystem::applyPropertyWrapperParameter(
     anchor = apply->getFn();
   }
 
+  if (argLabel.hasDollarPrefix() && (!param || !param->hasAttachedPropertyWrapper())) {
+    if (!shouldAttemptFixes())
+      return getTypeMatchFailure(locator);
+
+    addConstraint(matchKind, paramType, wrapperType, locator);
+    auto *fix = AddPropertyWrapperAttribute::create(*this, wrapperType, getConstraintLocator(locator));
+    if (recordFix(fix))
+      return getTypeMatchFailure(locator);
+
+    return getTypeMatchSuccess();
+  }
+
   PropertyWrapperInitKind initKind;
   if (argLabel.hasDollarPrefix()) {
     auto attemptProjectedValueFix = [&](ConstraintFix *fix) -> ConstraintSystem::TypeMatchResult {

lib/Sema/CSSimplify.cpp

@@ -1420,9 +1420,10 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
             cs, cs.getConstraintLocator(loc)));
       }
 
-      if (auto *param = paramInfo.getPropertyWrapperParam(argIdx)) {
-        auto argLabel = argInfo->Labels[argIdx];
-        if (cs.applyPropertyWrapperParameter(paramTy, argTy, const_cast<ParamDecl *>(param),
+      auto *wrappedParam = paramInfo.getPropertyWrapperParam(argIdx);
+      auto argLabel = argument.getLabel();
+      if (wrappedParam || argLabel.hasDollarPrefix()) {
+        if (cs.applyPropertyWrapperParameter(paramTy, argTy, const_cast<ParamDecl *>(wrappedParam),
                                              argLabel, subKind, locator).isFailure()) {
           return cs.getTypeMatchFailure(loc);
         }

lib/Sema/ConstraintSystem.cpp

@@ -1162,10 +1162,8 @@ static FunctionType *
 unwrapPropertyWrapperParameterTypes(ConstraintSystem &cs, AbstractFunctionDecl *funcDecl,
                                     FunctionRefKind functionRefKind, FunctionType *functionType,
                                     ConstraintLocatorBuilder locator) {
-  // Only apply property wrappers to unapplied references to functions
-  // with wrapped parameters.
-  if (!AnyFunctionRef(funcDecl).hasPropertyWrapperParameters() ||
-      !(functionRefKind == FunctionRefKind::Compound ||
+  // Only apply property wrappers to unapplied references to functions.
+  if (!(functionRefKind == FunctionRefKind::Compound ||
         functionRefKind == FunctionRefKind::Unapplied)) {
     return functionType;
   }
@@ -1187,12 +1185,6 @@ unwrapPropertyWrapperParameterTypes(ConstraintSystem &cs, AbstractFunctionDecl *
   }
 
   for (unsigned i : indices(*paramList)) {
-    auto *paramDecl = paramList->get(i);
-    if (!paramDecl->hasAttachedPropertyWrapper()) {
-      adjustedParamTypes.push_back(paramTypes[i]);
-      continue;
-    }
-
     Identifier argLabel;
     if (functionRefKind == FunctionRefKind::Compound) {
       auto &context = cs.getASTContext();
@@ -1201,6 +1193,12 @@ unwrapPropertyWrapperParameterTypes(ConstraintSystem &cs, AbstractFunctionDecl *
       argLabel = context.getIdentifier(argLabelToken.getText());
     }
 
+    auto *paramDecl = paramList->get(i);
+    if (!paramDecl->hasAttachedPropertyWrapper() && !argLabel.hasDollarPrefix()) {
+      adjustedParamTypes.push_back(paramTypes[i]);
+      continue;
+    }
+
     auto *wrappedType = cs.createTypeVariable(cs.getConstraintLocator(locator), 0);
     auto paramType = paramTypes[i].getParameterType();
     auto paramLabel = paramTypes[i].getLabel();
@@ -1209,7 +1207,8 @@ unwrapPropertyWrapperParameterTypes(ConstraintSystem &cs, AbstractFunctionDecl *
                                      ConstraintKind::Equal, locator);
   }
 
-  return FunctionType::get(adjustedParamTypes, functionType->getResult());
+  return FunctionType::get(adjustedParamTypes, functionType->getResult(),
+                           functionType->getExtInfo());
 }
 
 std::pair<Type, Type>

test/Sema/property_wrapper_parameter_invalid.swift

@@ -73,3 +73,13 @@ struct S {
   // expected-error@+1 {{property wrapper attribute on parameter not yet supported on subscript}}
   subscript(@Wrapper position: Int) -> Int { 0 }
 }
+
+func testInvalidArgLabel() {
+  func noWrappers(argLabel: Int) {}
+
+  // expected-error@+1 {{cannot use property wrapper projection argument; parameter does not have an attached property wrapper}}
+  let ref = noWrappers($argLabel:)
+
+  // expected-error@+1 {{cannot use property wrapper projection argument; parameter does not have an attached property wrapper}}
+  noWrappers($argLabel: 10)
+}