Merge pull request swiftlang#36568 from hborla/property-wrapper-constraint

hborla · web-flow · commit 6f4b62a93c09 · 2021-03-24T17:13:51.000-07:00
[ConstraintSystem] Add a property-wrapper constraint to allow for inference of implicit property wrappers
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -5581,16 +5581,16 @@ ERROR(property_wrapper_param_not_supported,none,
       (DescriptiveDeclKind))
 NOTE(property_wrapper_declared_here,none,
      "property wrapper type %0 declared here", (Identifier))
-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))
+ERROR(invalid_projection_argument,none,
+      "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,
+     "property wrapper has arguments in the wrapper attribute", ())
+NOTE(property_wrapper_no_init_projected_value,none,
+     "property wrapper type %0 does not support initialization from a "
+     "projected value", (Type))
 ERROR(property_wrapper_param_mutating,none,
       "property wrapper applied to parameter must have a nonmutating "
       "'wrappedValue' getter", ())
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -3329,7 +3329,7 @@ END_CAN_TYPE_WRAPPER(FunctionType, AnyFunctionType)
 struct ParameterListInfo {
   SmallBitVector defaultArguments;
   SmallBitVector acceptsUnlabeledTrailingClosures;
-  SmallVector<const ParamDecl *, 4> propertyWrappers;
+  SmallBitVector propertyWrappers;
 
 public:
   ParameterListInfo() { }
@@ -3346,7 +3346,7 @@ struct ParameterListInfo {
 
   /// The ParamDecl at the given index if the parameter has an applied
   /// property wrapper.
-  const ParamDecl *getPropertyWrapperParam(unsigned paramIdx) const;
+  bool hasExternalPropertyWrapper(unsigned paramIdx) const;
 
   /// Retrieve the number of non-defaulted parameters.
   unsigned numNonDefaultedParameters() const {
diff --git a/include/swift/Sema/CSFix.h b/include/swift/Sema/CSFix.h
@@ -122,12 +122,12 @@ enum class FixKind : uint8_t {
   /// the storage or property wrapper.
   UseWrappedValue,
 
-  /// Add 'var projectedValue' to the property wrapper type to allow passing
-  /// a projection argument.
-  AddProjectedValue,
+  /// Allow a type that is not a property wrapper to be used as a property
+  /// wrapper.
+  AllowInvalidPropertyWrapperType,
 
-  /// Add '@propertyWrapper' to a nominal type declaration.
-  AddPropertyWrapperAttribute,
+  /// Remove the '$' prefix from an argument label or parameter name.
+  RemoveProjectedValueArgument,
 
   /// Instead of spelling out `subscript` directly, use subscript operator.
   UseSubscriptOperator,
@@ -984,37 +984,40 @@ class UseWrappedValue final : public ConstraintFix {
                                  ConstraintLocator *locator);
 };
 
-class AddProjectedValue final : public ConstraintFix {
+class AllowInvalidPropertyWrapperType final : public ConstraintFix {
   Type wrapperType;
 
-  AddProjectedValue(ConstraintSystem &cs, Type wrapper,
-                    ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AddProjectedValue, locator), wrapperType(wrapper) {}
+  AllowInvalidPropertyWrapperType(ConstraintSystem &cs, Type wrapperType,
+                                  ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowInvalidPropertyWrapperType, locator),
+        wrapperType(wrapperType) {}
 
 public:
-  static AddProjectedValue *create(ConstraintSystem &cs, Type wrapper,
-                                   ConstraintLocator *locator);
+  static AllowInvalidPropertyWrapperType *create(ConstraintSystem &cs, Type wrapperType,
+                                                 ConstraintLocator *locator);
 
   std::string getName() const override {
-    return "add 'var projectedValue' to pass a projection argument";
+    return "allow invalid property wrapper type";
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 };
 
-class AddPropertyWrapperAttribute final : public ConstraintFix {
+class RemoveProjectedValueArgument final : public ConstraintFix {
   Type wrapperType;
+  ParamDecl *param;
 
-  AddPropertyWrapperAttribute(ConstraintSystem &cs, Type wrapper,
-                              ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AddPropertyWrapperAttribute, locator), wrapperType(wrapper) {}
+  RemoveProjectedValueArgument(ConstraintSystem &cs, Type wrapper,
+                               ParamDecl *param, ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::RemoveProjectedValueArgument, locator),
+        wrapperType(wrapper), param(param) {}
 
 public:
-  static AddPropertyWrapperAttribute *create(ConstraintSystem &cs, Type wrapper,
-                                             ConstraintLocator *locator);
+  static RemoveProjectedValueArgument *create(ConstraintSystem &cs, Type wrapper,
+                                              ParamDecl *param, ConstraintLocator *locator);
 
   std::string getName() const override {
-    return "add '@propertyWrapper'";
+    return "remove '$' from argument label";
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
diff --git a/include/swift/Sema/Constraint.h b/include/swift/Sema/Constraint.h
@@ -187,6 +187,9 @@ enum class ConstraintKind : char {
   /// - If base is a protocol metatype, this constraint becomes a conformance
   ///   check instead of an equality.
   UnresolvedMemberChainBase,
+  /// The first type is a property wrapper with a wrapped-value type
+  /// equal to the second type.
+  PropertyWrapper,
 };
 
 /// Classification of the different kinds of constraints.
@@ -586,6 +589,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::ValueMember:
     case ConstraintKind::UnresolvedValueMember:
     case ConstraintKind::ValueWitness:
+    case ConstraintKind::PropertyWrapper:
       return ConstraintClassification::Member;
 
     case ConstraintKind::DynamicTypeOf:
diff --git a/include/swift/Sema/ConstraintSystem.h b/include/swift/Sema/ConstraintSystem.h
@@ -4595,6 +4595,11 @@ class ConstraintSystem {
       ArrayRef<TypeVariableType *> referencedOuterParameters,
       TypeMatchOptions flags, ConstraintLocatorBuilder locator);
 
+  /// Attempt to simplify a property wrapper constraint.
+  SolutionKind simplifyPropertyWrapperConstraint(Type wrapperType, Type wrappedValueType,
+                                                 TypeMatchOptions flags,
+                                                 ConstraintLocatorBuilder locator);
+
   /// Attempt to simplify a one-way constraint.
   SolutionKind simplifyOneWayConstraint(ConstraintKind kind,
                                         Type first, Type second,
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -967,7 +967,7 @@ ParameterListInfo::ParameterListInfo(
     }
 
     if (param->hasAttachedPropertyWrapper()) {
-      propertyWrappers[i] = param;
+      propertyWrappers.set(i);
     }
   }
 }
@@ -983,9 +983,8 @@ bool ParameterListInfo::acceptsUnlabeledTrailingClosureArgument(
       acceptsUnlabeledTrailingClosures[paramIdx];
 }
 
-const ParamDecl *
-ParameterListInfo::getPropertyWrapperParam(unsigned paramIdx) const {
-  return paramIdx < propertyWrappers.size() ? propertyWrappers[paramIdx] : nullptr;
+bool ParameterListInfo::hasExternalPropertyWrapper(unsigned paramIdx) const {
+  return paramIdx < propertyWrappers.size() ? propertyWrappers[paramIdx] : false;
 }
 
 /// Turn a param list into a symbolic and printable representation that does not
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5953,7 +5953,8 @@ Expr *ExprRewriter::coerceCallArguments(
       return true;
     };
 
-    if (auto *param = paramInfo.getPropertyWrapperParam(paramIdx)) {
+    if (paramInfo.hasExternalPropertyWrapper(paramIdx)) {
+      auto *param = getParameterAt(callee.getDecl(), paramIdx);
       auto appliedWrapper = appliedPropertyWrappers[appliedWrapperIndex++];
       auto wrapperType = solution.simplifyType(appliedWrapper.wrapperType);
       auto initKind = appliedWrapper.initKind;
diff --git a/lib/Sema/CSBindings.cpp b/lib/Sema/CSBindings.cpp
@@ -1313,7 +1313,8 @@ void PotentialBindings::infer(Constraint *constraint) {
 
   case ConstraintKind::ValueMember:
   case ConstraintKind::UnresolvedValueMember:
-  case ConstraintKind::ValueWitness: {
+  case ConstraintKind::ValueWitness:
+  case ConstraintKind::PropertyWrapper: {
     // If current type variable represents a member type of some reference,
     // it would be bound once member is resolved either to a actual member
     // type or to a hole if member couldn't be found.
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -3306,32 +3306,39 @@ 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);
   return true;
 }
 
-bool MissingProjectedValueFailure::diagnoseAsError() {
-  emitDiagnostic(diag::property_wrapper_param_no_projection, wrapperType);
+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 MissingPropertyWrapperAttributeFailure::diagnoseAsError() {
-  if (auto *param = getAsDecl<ParamDecl>(getAnchor())) {
-    emitDiagnostic(diag::invalid_implicit_property_wrapper, wrapperType);
+bool InvalidProjectedValueArgument::diagnoseAsError() {
+  emitDiagnostic(diag::invalid_projection_argument, param->hasImplicitPropertyWrapper());
 
-    // FIXME: emit a note and fix-it to add '@propertyWrapper' if the
-    // type is a nominal and in the same module.
+  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 {
-    emitDiagnostic(diag::property_wrapper_param_no_wrapper);
+    Type backingType;
+    if (param->hasImplicitPropertyWrapper()) {
+      backingType = getType(param->getPropertyWrapperBackingProperty());
+    } else {
+      backingType = param->getPropertyWrapperBackingPropertyType();
+    }
+
+    param->diagnose(diag::property_wrapper_no_init_projected_value, backingType);
   }
 
   return true;
diff --git a/lib/Sema/CSDiagnostics.h b/lib/Sema/CSDiagnostics.h
@@ -1079,24 +1079,26 @@ class MissingPropertyWrapperUnwrapFailure final
   bool diagnoseAsError() override;
 };
 
-class MissingProjectedValueFailure final : public FailureDiagnostic {
+class InvalidPropertyWrapperType final : public FailureDiagnostic {
   Type wrapperType;
 
 public:
-  MissingProjectedValueFailure(const Solution &solution, Type wrapper,
-                               ConstraintLocator *locator)
+  InvalidPropertyWrapperType(const Solution &solution, Type wrapper,
+                             ConstraintLocator *locator)
       : FailureDiagnostic(solution, locator), wrapperType(resolveType(wrapper)) {}
 
   bool diagnoseAsError() override;
 };
 
-class MissingPropertyWrapperAttributeFailure final : public FailureDiagnostic {
+class InvalidProjectedValueArgument final : public FailureDiagnostic {
   Type wrapperType;
+  ParamDecl *param;
 
 public:
-  MissingPropertyWrapperAttributeFailure(const Solution &solution, Type wrapper,
-                                         ConstraintLocator *locator)
-      : FailureDiagnostic(solution, locator), wrapperType(resolveType(wrapper)) {}
+  InvalidProjectedValueArgument(const Solution &solution, Type wrapper,
+                                ParamDecl *param, ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), wrapperType(resolveType(wrapper)),
+        param(param) {}
 
   bool diagnoseAsError() override;
 };
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -646,25 +646,26 @@ UseWrappedValue *UseWrappedValue::create(ConstraintSystem &cs,
       UseWrappedValue(cs, propertyWrapper, base, wrapper, locator);
 }
 
-bool AddProjectedValue::diagnose(const Solution &solution, bool asNote) const {
-  MissingProjectedValueFailure failure(solution, wrapperType, getLocator());
+bool AllowInvalidPropertyWrapperType::diagnose(const Solution &solution, bool asNote) const {
+  InvalidPropertyWrapperType failure(solution, wrapperType, getLocator());
   return failure.diagnose(asNote);
 }
 
-AddProjectedValue *AddProjectedValue::create(ConstraintSystem &cs, Type wrapperType,
-                                             ConstraintLocator *locator) {
-  return new (cs.getAllocator()) AddProjectedValue(cs, wrapperType, locator);
+AllowInvalidPropertyWrapperType *
+AllowInvalidPropertyWrapperType::create(ConstraintSystem &cs, Type wrapperType,
+                                        ConstraintLocator *locator) {
+  return new (cs.getAllocator()) AllowInvalidPropertyWrapperType(cs, wrapperType, locator);
 }
 
-bool AddPropertyWrapperAttribute::diagnose(const Solution &solution, bool asNote) const {
-  MissingPropertyWrapperAttributeFailure failure(solution, wrapperType, getLocator());
+bool RemoveProjectedValueArgument::diagnose(const Solution &solution, bool asNote) const {
+  InvalidProjectedValueArgument failure(solution, wrapperType, param, getLocator());
   return failure.diagnose(asNote);
 }
 
-AddPropertyWrapperAttribute *AddPropertyWrapperAttribute::create(ConstraintSystem &cs,
-                                                                 Type wrapperType,
-                                                                 ConstraintLocator *locator) {
-  return new (cs.getAllocator()) AddPropertyWrapperAttribute(cs, wrapperType, locator);
+RemoveProjectedValueArgument *
+RemoveProjectedValueArgument::create(ConstraintSystem &cs, Type wrapperType,
+                                      ParamDecl *param, ConstraintLocator *locator) {
+  return new (cs.getAllocator()) RemoveProjectedValueArgument(cs, wrapperType, param, locator);
 }
 
 bool UseSubscriptOperator::diagnose(const Solution &solution,
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -4051,12 +4051,29 @@ ConstraintSystem::applyPropertyWrapperToParameter(
     anchor = apply->getFn();
   }
 
-  if (argLabel.hasDollarPrefix() && (!param || !param->hasAttachedPropertyWrapper())) {
+  auto supportsProjectedValueInit = [&](ParamDecl *param) -> bool {
+    if (!param->hasAttachedPropertyWrapper())
+      return false;
+
+    if (param->hasImplicitPropertyWrapper())
+      return true;
+
+    if (param->getAttachedPropertyWrappers().front()->getArg())
+      return false;
+
+    auto wrapperInfo = param->getAttachedPropertyWrapperTypeInfo(0);
+    return wrapperInfo.projectedValueVar && wrapperInfo.hasProjectedValueInit;
+  };
+
+  if (argLabel.hasDollarPrefix() && (!param || !supportsProjectedValueInit(param))) {
     if (!shouldAttemptFixes())
       return getTypeMatchFailure(locator);
 
-    addConstraint(matchKind, paramType, wrapperType, locator);
-    auto *fix = AddPropertyWrapperAttribute::create(*this, wrapperType, getConstraintLocator(locator));
+    if (paramType->hasTypeVariable())
+      recordPotentialHole(paramType);
+
+    auto *loc = getConstraintLocator(locator);
+    auto *fix = RemoveProjectedValueArgument::create(*this, wrapperType, param, loc);
     if (recordFix(fix))
       return getTypeMatchFailure(locator);
 
@@ -4065,32 +4082,12 @@ ConstraintSystem::applyPropertyWrapperToParameter(
 
   PropertyWrapperInitKind initKind;
   if (argLabel.hasDollarPrefix()) {
-    auto attemptProjectedValueFix = [&](ConstraintFix *fix) -> ConstraintSystem::TypeMatchResult {
-      if (shouldAttemptFixes()) {
-        if (paramType->hasTypeVariable())
-          recordPotentialHole(paramType);
-
-        if (!recordFix(fix))
-          return getTypeMatchSuccess();
-      }
-
-      return getTypeMatchFailure(locator);
-    };
-
-    auto typeInfo = wrapperType->getAnyNominal()->getPropertyWrapperTypeInfo();
-    if (!typeInfo.projectedValueVar) {
-      auto *fix = AddProjectedValue::create(*this, wrapperType, getConstraintLocator(locator));
-      return attemptProjectedValueFix(fix);
-    }
-
     Type projectionType = computeProjectedValueType(param, wrapperType);
     addConstraint(matchKind, paramType, projectionType, locator);
-
-    if (!param->hasImplicitPropertyWrapper() &&
-        param->getAttachedPropertyWrappers().front()->getArg()) {
-      auto *fix = UseWrappedValue::create(*this, param, /*base=*/Type(), wrapperType,
-                                          getConstraintLocator(locator));
-      return attemptProjectedValueFix(fix);
+    if (param->hasImplicitPropertyWrapper()) {
+      auto wrappedValueType = getType(param->getPropertyWrapperWrappedValueVar());
+      addConstraint(ConstraintKind::PropertyWrapper, projectionType, wrappedValueType,
+                    getConstraintLocator(param));
     }
 
     initKind = PropertyWrapperInitKind::ProjectedValue;
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
diff --git a/lib/Sema/Constraint.cpp b/lib/Sema/Constraint.cpp
diff --git a/test/Sema/property_wrapper_parameter.swift b/test/Sema/property_wrapper_parameter.swift
diff --git a/test/Sema/property_wrapper_parameter_invalid.swift b/test/Sema/property_wrapper_parameter_invalid.swift

Original file line number	Diff line number	Diff line change
`@@ -967,7 +967,7 @@ ParameterListInfo::ParameterListInfo(`
`967`	`967`	`}`
`968`	`968`
`969`	`969`	`if (param->hasAttachedPropertyWrapper()) {`
`970`		`- propertyWrappers[i] = param;`
	`970`	`+ propertyWrappers.set(i);`
`971`	`971`	`}`
`972`	`972`	`}`
`973`	`973`	`}`
`@@ -983,9 +983,8 @@ bool ParameterListInfo::acceptsUnlabeledTrailingClosureArgument(`
`983`	`983`	`acceptsUnlabeledTrailingClosures[paramIdx];`
`984`	`984`	`}`
`985`	`985`
`986`		`-const ParamDecl *`
`987`		`-ParameterListInfo::getPropertyWrapperParam(unsigned paramIdx) const {`
`988`		`- return paramIdx < propertyWrappers.size() ? propertyWrappers[paramIdx] : nullptr;`
	`986`	`+bool ParameterListInfo::hasExternalPropertyWrapper(unsigned paramIdx) const {`
	`987`	`+ return paramIdx < propertyWrappers.size() ? propertyWrappers[paramIdx] : false;`
`989`	`988`	`}`
`990`	`989`
`991`	`990`	`/// Turn a param list into a symbolic and printable representation that does not`