[ConstraintSystem] Emit an error message when trying to pass a property

wrapper projection argument to a wrapped parameter with arguments in the
wrapper attribute.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5484,12 +5484,12 @@ ERROR(property_wrapper_attribute_not_on_property, none,
       (Identifier))
 NOTE(property_wrapper_declared_here,none,
      "property wrapper type %0 declared here", (Identifier))
-ERROR(property_wrapper_param_arg, none,
-      "property wrapper attributes applied to parameters cannot have arguments",
-      ())
 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_projection_invalid,none,
+      "cannot use property wrapper projection argument; "
+      "pass wrapped value type %0 instead", (Type))
 ERROR(property_wrapper_param_mutating,none,
       "property wrapper applied to parameter must have a nonmutating "
       "'wrappedValue' getter", ())

lib/Sema/CSDiagnostics.cpp

@@ -3291,6 +3291,13 @@ bool MissingPropertyWrapperUnwrapFailure::diagnoseAsError() {
     return true;
   }
 
+  if (isa<ParamDecl>(getProperty())) {
+    auto wrapperType = getToType();
+    auto wrappedValueType = computeWrappedValueType(getProperty(), wrapperType);
+    emitDiagnostic(diag::property_wrapper_param_projection_invalid, wrappedValueType);
+    return true;
+  }
+
   emitDiagnostic(diag::incorrect_property_wrapper_reference, getPropertyName(),
                  getFromType(), getToType(), true)
       .fixItRemoveChars(getLoc(), endLoc);

lib/Sema/CSGen.cpp

@@ -4070,23 +4070,34 @@ ConstraintSystem::applyPropertyWrapperParameter(
 
   PropertyWrapperInitKind initKind;
   if (argLabel.hasDollarPrefix()) {
-    auto typeInfo = param->getAttachedPropertyWrapperTypeInfo(0);
-    if (!typeInfo.projectedValueVar) {
+    auto attemptProjectedValueFix = [&](ConstraintFix *fix) -> ConstraintSystem::TypeMatchResult {
       if (shouldAttemptFixes()) {
         if (paramType->hasTypeVariable())
           recordPotentialHole(paramType);
 
-        auto *fix = AddProjectedValue::create(*this, wrapperType, getConstraintLocator(locator));
         if (!recordFix(fix))
           return getTypeMatchSuccess();
       }
 
       return getTypeMatchFailure(locator);
+    };
+
+    auto typeInfo = param->getAttachedPropertyWrapperTypeInfo(0);
+    if (!typeInfo.projectedValueVar) {
+      auto *fix = AddProjectedValue::create(*this, wrapperType, getConstraintLocator(locator));
+      return attemptProjectedValueFix(fix);
     }
 
     auto projectionType = wrapperType->getTypeOfMember(param->getModuleContext(),
                                                        typeInfo.projectedValueVar);
     addConstraint(matchKind, paramType, projectionType, locator);
+
+    if (param->getAttachedPropertyWrappers().front()->getArg()) {
+      auto *fix = UseWrappedValue::create(*this, param, /*base=*/Type(), wrapperType,
+                                          getConstraintLocator(locator));
+      return attemptProjectedValueFix(fix);
+    }
+
     initKind = PropertyWrapperInitKind::ProjectedValue;
   } else {
     generateWrappedPropertyTypeConstraints(*this, wrapperType, param, paramType);

lib/Sema/TypeCheckAttr.cpp

@@ -2995,12 +2995,6 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
       return;
     }
 
-    if (isa<ParamDecl>(D) && attr->getArg()) {
-      diagnose(attr->getArg()->getLoc(), diag::property_wrapper_param_arg);
-      attr->setInvalid();
-      return;
-    }
-
     return;
   }
 

test/Sema/property_wrapper_parameter_invalid.swift

@@ -41,3 +41,30 @@ func testNoProjection(message: String) {
   // expected-error@+1 {{cannot use property wrapper projection parameter; wrapper 'NoProjection<String>' does not have a 'projectedValue'}}
   takesNoProjectionWrapper($value: message)
 }
+
+struct Projection<T> {
+  var value: T
+}
+
+@propertyWrapper
+struct Wrapper<T> {
+  init(wrappedValue: T) {
+    self.wrappedValue = wrappedValue
+  }
+
+  init(projectedValue: Projection<T>) {
+    self.wrappedValue = projectedValue.value
+  }
+
+  var wrappedValue: T
+  var projectedValue: Projection<T> { Projection(value: wrappedValue) }
+}
+
+func hasWrapperAttributeArg<T>(@Wrapper() value: T) {}
+
+func testWrapperAttributeArg(projection: Projection<Int>) {
+  hasWrapperAttributeArg(value: projection.value)
+
+  // expected-error@+1 {{cannot use property wrapper projection argument; pass wrapped value type 'Int' instead}}
+  hasWrapperAttributeArg($value: projection)
+}