[Diagnostics] Add back a dedicated fix/diagnostic for using an invalid

type as a property wrapper.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5575,7 +5575,8 @@ ERROR(property_wrapper_param_not_supported,none,
 NOTE(property_wrapper_declared_here,none,
      "property wrapper type %0 declared here", (Identifier))
 ERROR(invalid_projection_argument,none,
-      "cannot use property wrapper projection argument", ())
+      "cannot use property wrapper projection %select{argument|parameter}0",
+      (bool))
 NOTE(property_wrapper_param_no_wrapper,none,
      "parameter %0 does not have an attached property wrapper", (Identifier))
 NOTE(property_wrapper_param_attr_arg,none,

include/swift/Sema/CSFix.h

@@ -122,6 +122,10 @@ enum class FixKind : uint8_t {
   /// the storage or property wrapper.
   UseWrappedValue,
 
+  /// Allow a type that is not a property wrapper to be used as a property
+  /// wrapper.
+  AllowInvalidPropertyWrapperType,
+
   /// Remove the '$' prefix from an argument label or parameter name.
   RemoveProjectedValueArgument,
 
@@ -980,6 +984,25 @@ class UseWrappedValue final : public ConstraintFix {
                                  ConstraintLocator *locator);
 };
 
+class AllowInvalidPropertyWrapperType final : public ConstraintFix {
+  Type wrapperType;
+
+  AllowInvalidPropertyWrapperType(ConstraintSystem &cs, Type wrapperType,
+                                  ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowInvalidPropertyWrapperType, locator),
+        wrapperType(wrapperType) {}
+
+public:
+  static AllowInvalidPropertyWrapperType *create(ConstraintSystem &cs, Type wrapperType,
+                                                 ConstraintLocator *locator);
+
+  std::string getName() const override {
+    return "allow invalid property wrapper type";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+};
+
 class RemoveProjectedValueArgument final : public ConstraintFix {
   Type wrapperType;
   ParamDecl *param;

lib/Sema/CSDiagnostics.cpp

@@ -3312,20 +3312,33 @@ bool MissingPropertyWrapperUnwrapFailure::diagnoseAsError() {
   return true;
 }
 
+bool InvalidPropertyWrapperType::diagnoseAsError() {
+  // The property wrapper constraint is currently only used for
+  // implicit property wrappers on closure parameters.
+  auto *wrappedVar = getAsDecl<VarDecl>(getAnchor());
+  assert(wrappedVar->hasImplicitPropertyWrapper());
+
+  emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
+  return true;
+}
+
 bool InvalidProjectedValueArgument::diagnoseAsError() {
-  if (param->hasImplicitPropertyWrapper()) {
-    emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
-  } else {
-    emitDiagnostic(diag::invalid_projection_argument);
+  emitDiagnostic(diag::invalid_projection_argument, param->hasImplicitPropertyWrapper());
 
-    if (!param->hasAttachedPropertyWrapper()) {
-      param->diagnose(diag::property_wrapper_param_no_wrapper, param->getName());
-    } else if (param->getAttachedPropertyWrappers().front()->getArg()) {
-      param->diagnose(diag::property_wrapper_param_attr_arg);
+  if (!param->hasAttachedPropertyWrapper()) {
+    param->diagnose(diag::property_wrapper_param_no_wrapper, param->getName());
+  } else if (!param->hasImplicitPropertyWrapper() &&
+             param->getAttachedPropertyWrappers().front()->getArg()) {
+    param->diagnose(diag::property_wrapper_param_attr_arg);
+  } else {
+    Type backingType;
+    if (param->hasImplicitPropertyWrapper()) {
+      backingType = getType(param->getPropertyWrapperBackingProperty());
     } else {
-      auto backingType = param->getPropertyWrapperBackingPropertyType();
-      param->diagnose(diag::property_wrapper_no_init_projected_value, backingType);
+      backingType = param->getPropertyWrapperBackingPropertyType();
     }
+
+    param->diagnose(diag::property_wrapper_no_init_projected_value, backingType);
   }
 
   return true;

lib/Sema/CSDiagnostics.h

@@ -1079,6 +1079,17 @@ class MissingPropertyWrapperUnwrapFailure final
   bool diagnoseAsError() override;
 };
 
+class InvalidPropertyWrapperType final : public FailureDiagnostic {
+  Type wrapperType;
+
+public:
+  InvalidPropertyWrapperType(const Solution &solution, Type wrapper,
+                             ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), wrapperType(resolveType(wrapper)) {}
+
+  bool diagnoseAsError() override;
+};
+
 class InvalidProjectedValueArgument final : public FailureDiagnostic {
   Type wrapperType;
   ParamDecl *param;

lib/Sema/CSFix.cpp

@@ -646,6 +646,17 @@ UseWrappedValue *UseWrappedValue::create(ConstraintSystem &cs,
       UseWrappedValue(cs, propertyWrapper, base, wrapper, locator);
 }
 
+bool AllowInvalidPropertyWrapperType::diagnose(const Solution &solution, bool asNote) const {
+  InvalidPropertyWrapperType failure(solution, wrapperType, getLocator());
+  return failure.diagnose(asNote);
+}
+
+AllowInvalidPropertyWrapperType *
+AllowInvalidPropertyWrapperType::create(ConstraintSystem &cs, Type wrapperType,
+                                        ConstraintLocator *locator) {
+  return new (cs.getAllocator()) AllowInvalidPropertyWrapperType(cs, wrapperType, locator);
+}
+
 bool RemoveProjectedValueArgument::diagnose(const Solution &solution, bool asNote) const {
   InvalidProjectedValueArgument failure(solution, wrapperType, param, getLocator());
   return failure.diagnose(asNote);

lib/Sema/CSSimplify.cpp

@@ -8127,23 +8127,23 @@ ConstraintSystem::simplifyPropertyWrapperConstraint(
   }
 
   ConstraintFix *fix = nullptr;
+  auto *wrappedVar = getAsDecl<VarDecl>(locator.getAnchor());
+  assert(wrappedVar && wrappedVar->hasAttachedPropertyWrapper());
 
   // The wrapper type must be a property wrapper.
-  auto *nominal = wrapperType->getAnyNominal();
+  auto *nominal = wrapperType->getDesugaredType()->getAnyNominal();
   if (!(nominal && nominal->getAttrs().hasAttribute<PropertyWrapperAttr>())) {
-    if (auto *paramDecl = getAsDecl<ParamDecl>(locator.getAnchor())) {
-      fix = RemoveProjectedValueArgument::create(*this, wrapperType, paramDecl,
-                                                 getConstraintLocator(paramDecl));
-    } else {
-      return SolutionKind::Error;
-    }
+    fix = AllowInvalidPropertyWrapperType::create(*this, wrapperType,
+                                                  getConstraintLocator(locator));
   }
 
   auto typeInfo = nominal->getPropertyWrapperTypeInfo();
-  if (!(typeInfo.projectedValueVar && typeInfo.hasProjectedValueInit)) {
-    if (auto *paramDecl = getAsDecl<ParamDecl>(locator.getAnchor())) {
-      fix = RemoveProjectedValueArgument::create(*this, wrapperType, paramDecl,
-                                                 getConstraintLocator(paramDecl));
+
+  // Implicit property wrappers must support projected-value initialization.
+  if (!fix && wrappedVar->hasImplicitPropertyWrapper()) {
+    if (!(typeInfo.projectedValueVar && typeInfo.hasProjectedValueInit)) {
+      fix = RemoveProjectedValueArgument::create(*this, wrapperType, cast<ParamDecl>(wrappedVar),
+                                                 getConstraintLocator(locator));
     }
   }
 
@@ -10833,6 +10833,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::SkipUnhandledConstructInResultBuilder:
   case FixKind::UsePropertyWrapper:
   case FixKind::UseWrappedValue:
+  case FixKind::AllowInvalidPropertyWrapperType:
   case FixKind::RemoveProjectedValueArgument:
   case FixKind::ExpandArrayIntoVarargs:
   case FixKind::UseRawValue:

test/Sema/property_wrapper_parameter_invalid.swift

@@ -41,6 +41,12 @@ func testNoProjection(message: String) {
 
   // expected-error@+1 {{cannot use property wrapper projection argument}}
   takesNoProjectionWrapper($value: message)
+
+  // expected-error@+2 {{cannot use property wrapper projection parameter}}
+  // expected-note@+1 {{property wrapper type 'NoProjection<Int>' does not support initialization from a projected value}}
+  let _: (NoProjection<Int>) -> Int = { $value in
+    return value
+  }
 }
 
 struct Projection<T> {