Merge pull request swiftlang#25132 from DougGregor/property-wrappers-rename

Author: swift-ci

docs/SIL.rst

@@ -2333,15 +2333,15 @@ with a sequence that also correctly destroys the current value.
 This instruction is only valid in Raw SIL and is rewritten as appropriate
 by the definitive initialization pass.
 
-assign_by_delegate
+assign_by_wrapper
 ``````````````````
 ::
 
-  sil-instruction ::= 'assign_by_delegate' sil-operand 'to' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand
+  sil-instruction ::= 'assign_by_wrapper' sil-operand 'to' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand
 
-  assign_by_delegate %0 : $S to %1 : $*T, init %2 : $F, set %3 : $G
+  assign_by_wrapper %0 : $S to %1 : $*T, init %2 : $F, set %3 : $G
   // $S can be a value or address type
-  // $T must be the type of a property delegate.
+  // $T must be the type of a property wrapper.
   // $F must be a function type, taking $S as a single argument and returning $T
   // $G must be a function type, taking $S as a single argument and with not return value
 

include/swift/AST/ASTContext.h

@@ -838,11 +838,11 @@ class ASTContext final {
                                               const IterableDeclContext *idc,
                                               LazyMemberLoader *lazyLoader);
 
-  /// Access the side cache for property delegate backing property types,
+  /// Access the side cache for property wrapper backing property types,
   /// used because TypeChecker::typeCheckBinding() needs somewhere to stash
   /// the backing property type.
-  Type getSideCachedPropertyDelegateBackingPropertyType(VarDecl *var) const;
-  void setSideCachedPropertyDelegateBackingPropertyType(VarDecl *var,
+  Type getSideCachedPropertyWrapperBackingPropertyType(VarDecl *var) const;
+  void setSideCachedPropertyWrapperBackingPropertyType(VarDecl *var,
                                                         Type type);
 
   /// Returns memory usage of this ASTContext.

include/swift/AST/ASTTypeIDZone.def

@@ -17,7 +17,7 @@
 SWIFT_TYPEID_NAMED(NominalTypeDecl *, NominalTypeDecl)
 SWIFT_TYPEID_NAMED(VarDecl *, VarDecl)
 SWIFT_TYPEID(Type)
-SWIFT_TYPEID(PropertyDelegateBackingPropertyInfo)
-SWIFT_TYPEID(PropertyDelegateTypeInfo)
+SWIFT_TYPEID(PropertyWrapperBackingPropertyInfo)
+SWIFT_TYPEID(PropertyWrapperTypeInfo)
 SWIFT_TYPEID_NAMED(CustomAttr *, CustomAttr)
 SWIFT_TYPEID_NAMED(TypeAliasDecl *, TypeAliasDecl)

include/swift/AST/ASTTypeIDs.h

@@ -22,8 +22,8 @@ namespace swift {
 
 class CustomAttr;
 class NominalTypeDecl;
-struct PropertyDelegateBackingPropertyInfo;
-struct PropertyDelegateTypeInfo;
+struct PropertyWrapperBackingPropertyInfo;
+struct PropertyWrapperTypeInfo;
 class Type;
 class VarDecl;
 class TypeAliasDecl;

include/swift/AST/Attr.def

@@ -399,7 +399,7 @@ SIMPLE_DECL_ATTR(_implementationOnly, ImplementationOnly,
 DECL_ATTR(_custom, Custom,
   OnAnyDecl | UserInaccessible,
   85)
-SIMPLE_DECL_ATTR(_propertyDelegate, PropertyDelegate,
+SIMPLE_DECL_ATTR(_propertyWrapper, PropertyWrapper,
   OnStruct | OnClass | OnEnum,
   86)
 SIMPLE_DECL_ATTR(_disfavoredOverload, DisfavoredOverload,

include/swift/AST/Decl.h

@@ -78,8 +78,8 @@ namespace swift {
   class ParameterTypeFlags;
   class Pattern;
   struct PrintOptions;
-  struct PropertyDelegateBackingPropertyInfo;
-  struct PropertyDelegateTypeInfo;
+  struct PropertyWrapperBackingPropertyInfo;
+  struct PropertyWrapperTypeInfo;
   class ProtocolDecl;
   class ProtocolType;
   struct RawComment;
@@ -391,8 +391,8 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// FIXME: Remove this once LLDB has proper support for resilience.
     IsREPLVar : 1,
 
-    /// Whether this is the backing storage for a property delegate.
-    IsPropertyDelegateBackingProperty : 1
+    /// Whether this is the backing storage for a property wrapper.
+    IsPropertyWrapperBackingProperty : 1
   );
 
   SWIFT_INLINE_BITFIELD(ParamDecl, VarDecl, 1 + NumDefaultArgumentKindBits,
@@ -3394,8 +3394,8 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Is this a key path type?
   Optional<KeyPathTypeKind> getKeyPathTypeKind() const;
 
-  /// Retrieve information about this type as a property delegate.
-  PropertyDelegateTypeInfo getPropertyDelegateTypeInfo() const;
+  /// Retrieve information about this type as a property wrapper.
+  PropertyWrapperTypeInfo getPropertyWrapperTypeInfo() const;
 
 private:
   /// Predicate used to filter StoredPropertyRange.
@@ -4745,14 +4745,14 @@ class AbstractStorageDecl : public ValueDecl {
 };
 
 /// Describes which synthesized property for a property with an attached
-/// delegate is being referenced.
-enum class PropertyDelegateSynthesizedPropertyKind {
+/// wrapper is being referenced.
+enum class PropertyWrapperSynthesizedPropertyKind {
   /// The backing storage property, which is a stored property of the
-  /// delegate type.
+  /// wrapper type.
   Backing,
-  /// A storage delegate (e.g., `$foo`), which is a wrapper over the
-  /// delegate instance's `delegateValue` property.
-  StorageDelegate,
+  /// A storage wrapper (e.g., `$foo`), which is a wrapper over the
+  /// wrapper instance's `wrapperValue` property.
+  StorageWrapper,
 };
 
 /// VarDecl - 'var' and 'let' declarations.
@@ -4785,7 +4785,7 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsDebuggerVar = false;
     Bits.VarDecl.IsREPLVar = false;
     Bits.VarDecl.HasNonPatternBindingInit = false;
-    Bits.VarDecl.IsPropertyDelegateBackingProperty = false;
+    Bits.VarDecl.IsPropertyWrapperBackingProperty = false;
   }
 
   /// This is the type specified, including location information.
@@ -5080,64 +5080,64 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsREPLVar = IsREPLVar;
   }
 
-  /// Retrieve the custom attribute that attaches a property delegate to this
+  /// Retrieve the custom attribute that attaches a property wrapper to this
   /// property.
-  CustomAttr *getAttachedPropertyDelegate() const;
+  CustomAttr *getAttachedPropertyWrapper() const;
 
-  /// Retrieve the type of the attached property delegate as a contextual
+  /// Retrieve the type of the attached property wrapper as a contextual
   /// type.
   ///
-  /// \returns a NULL type for properties without attached delegates,
-  /// an error type when the property delegate type itself is erroneous,
-  /// or the delegate type itself, which may involve unbound generic
+  /// \returns a NULL type for properties without attached wrappers,
+  /// an error type when the property wrapper type itself is erroneous,
+  /// or the wrapper type itself, which may involve unbound generic
   /// types.
-  Type getAttachedPropertyDelegateType() const;
+  Type getAttachedPropertyWrapperType() const;
 
-  /// Retrieve information about the attached property delegate type.
-  PropertyDelegateTypeInfo getAttachedPropertyDelegateTypeInfo() const;
+  /// Retrieve information about the attached property wrapper type.
+  PropertyWrapperTypeInfo getAttachedPropertyWrapperTypeInfo() const;
 
-  /// Retrieve the fully resolved attached property delegate type.
+  /// Retrieve the fully resolved attached property wrapper type.
   ///
   /// This type will be the fully-resolved form of
-  /// \c getAttachedPropertyDelegateType(), which will not contain any
+  /// \c getAttachedPropertyWrapperType(), which will not contain any
   /// unbound generic types. It will be the type of the backing property.
-  Type getPropertyDelegateBackingPropertyType() const;
+  Type getPropertyWrapperBackingPropertyType() const;
 
   /// Retrieve information about the backing properties of the attached
-  /// property delegate.
-  PropertyDelegateBackingPropertyInfo
-      getPropertyDelegateBackingPropertyInfo() const;
+  /// property wrapper.
+  PropertyWrapperBackingPropertyInfo
+      getPropertyWrapperBackingPropertyInfo() const;
 
   /// Retrieve the backing storage property for a property that has an
-  /// attached property delegate.
+  /// attached property wrapper.
   ///
   /// The backing storage property will be a stored property of the
-  /// delegate's type. This will be equivalent to
-  /// \c getAttachedPropertyDelegateType() when it is fully-specified;
-  /// if \c getAttachedPropertyDelegateType() involves an unbound
+  /// wrapper's type. This will be equivalent to
+  /// \c getAttachedPropertyWrapperType() when it is fully-specified;
+  /// if \c getAttachedPropertyWrapperType() involves an unbound
   /// generic type, the backing storage property will be the appropriate
   /// bound generic version.
-  VarDecl *getPropertyDelegateBackingProperty() const;
+  VarDecl *getPropertyWrapperBackingProperty() const;
 
-  /// Whether this is a property with a property delegate that was initialized
+  /// Whether this is a property with a property wrapper that was initialized
   /// via a value of the original type, e.g.,
   ///
   /// \code
   /// @Lazy var i = 17
   /// \end
-  bool isPropertyDelegateInitializedWithInitialValue() const;
+  bool isPropertyWrapperInitializedWithInitialValue() const;
 
   /// If this property is the backing storage for a property with an attached
-  /// property delegate, return the original property.
+  /// property wrapper, return the original property.
   ///
   /// \param kind If not \c None, only returns the original property when
   /// \c this property is the specified synthesized property.
-  VarDecl *getOriginalDelegatedProperty(
-      Optional<PropertyDelegateSynthesizedPropertyKind> kind = None) const;
+  VarDecl *getOriginalWrappedProperty(
+      Optional<PropertyWrapperSynthesizedPropertyKind> kind = None) const;
 
-  /// Set the property that delegates to this property as it's backing
+  /// Set the property that wraps to this property as it's backing
   /// property.
-  void setOriginalDelegatedProperty(VarDecl *originalProperty);
+  void setOriginalWrappedProperty(VarDecl *originalProperty);
 
   /// Return the Objective-C runtime name for this property.
   Identifier getObjCPropertyName() const;
@@ -5164,7 +5164,7 @@ class VarDecl : public AbstractStorageDecl {
   /// initializer.
   ///
   /// \param preferDeclaredProperties When encountering a `lazy` property
-  /// or a property that has an attached property delegate, prefer the
+  /// or a property that has an attached property wrapper, prefer the
   /// actual declared property (which may or may not be considered "stored"
   /// as the moment) to the backing storage property. Otherwise, the stored
   /// backing property will be treated as the member-initialized property.

include/swift/AST/DiagnosticsSema.def

@@ -4340,88 +4340,88 @@ WARNING(hashvalue_implementation,none,
         (Type))
 
 //------------------------------------------------------------------------------
-// MARK: property delegate diagnostics
+// MARK: property wrapper diagnostics
 //------------------------------------------------------------------------------
-ERROR(property_delegate_no_value_property, none,
-  "property delegate type %0 does not contain a non-static property "
+ERROR(property_wrapper_no_value_property, none,
+  "property wrapper type %0 does not contain a non-static property "
   "named %1", (Type, Identifier))
-ERROR(property_delegate_ambiguous_value_property, none,
-  "property delegate type %0 has multiple non-static properties "
+ERROR(property_wrapper_ambiguous_value_property, none,
+  "property wrapper type %0 has multiple non-static properties "
   "named %1", (Type, Identifier))
-ERROR(property_delegate_wrong_initial_value_init, none,
+ERROR(property_wrapper_wrong_initial_value_init, none,
       "'init(initialValue:)' parameter type (%0) must be the same as its "
       "'value' property type (%1) or an @autoclosure thereof", (Type, Type))
-ERROR(property_delegate_failable_init, none,
+ERROR(property_wrapper_failable_init, none,
       "%0 cannot be failable", (DeclName))
-ERROR(property_delegate_ambiguous_initial_value_init, none,
-  "property delegate type %0 has multiple initial-value initializers", (Type))
-ERROR(property_delegate_ambiguous_default_value_init, none,
-  "property delegate type %0 has multiple default-value initializers", (Type))
-ERROR(property_delegate_type_requirement_not_accessible,none,
+ERROR(property_wrapper_ambiguous_initial_value_init, none,
+  "property wrapper type %0 has multiple initial-value initializers", (Type))
+ERROR(property_wrapper_ambiguous_default_value_init, none,
+  "property wrapper type %0 has multiple default-value initializers", (Type))
+ERROR(property_wrapper_type_requirement_not_accessible,none,
       "%select{private|fileprivate|internal|public|open}0 %1 %2 cannot have "
-      "more restrictive access than its enclosing property delegate type %3 "
+      "more restrictive access than its enclosing property wrapper type %3 "
       "(which is %select{private|fileprivate|internal|public|open}4)",
       (AccessLevel, DescriptiveDeclKind, DeclName, Type, AccessLevel))
-ERROR(property_delegate_reserved_name,none,
-      "property delegate type name must start with an uppercase letter", ())
+ERROR(property_wrapper_reserved_name,none,
+      "property wrapper type name must start with an uppercase letter", ())
 
-ERROR(property_delegate_attribute_not_on_property, none,
-      "property delegate attribute %0 can only be applied to a property",
+ERROR(property_wrapper_attribute_not_on_property, none,
+      "property wrapper attribute %0 can only be applied to a property",
       (DeclName))
 
-ERROR(property_delegate_multiple,none,
-      "only one property delegate can be attached to a given property", ())
-NOTE(previous_property_delegate_here,none,
-      "previous property delegate specified here", ())
+ERROR(property_wrapper_multiple,none,
+      "only one property wrapper can be attached to a given property", ())
+NOTE(previous_property_wrapper_here,none,
+      "previous property wrapper specified here", ())
 
-ERROR(property_delegate_local,none,
-      "property delegates are not yet supported on local properties", ())
-ERROR(property_delegate_let, none,
-      "property delegate can only be applied to a 'var'",
+ERROR(property_wrapper_local,none,
+      "property wrappers are not yet supported on local properties", ())
+ERROR(property_wrapper_let, none,
+      "property wrapper can only be applied to a 'var'",
       ())
-ERROR(property_delegate_computed, none,
-      "property delegate cannot be applied to a computed property",
+ERROR(property_wrapper_computed, none,
+      "property wrapper cannot be applied to a computed property",
       ())
 
-ERROR(property_with_delegate_conflict_attribute,none,
-      "property %0 with a delegate cannot also be "
+ERROR(property_with_wrapper_conflict_attribute,none,
+      "property %0 with a wrapper cannot also be "
       "%select{lazy|@NSCopying|@NSManaged|weak|unowned|unmanaged}1",
       (DeclName, int))
-ERROR(property_delegate_not_single_var, none,
-      "property delegate can only apply to a single variable", ())
-ERROR(property_with_delegate_in_bad_context,none,
+ERROR(property_wrapper_not_single_var, none,
+      "property wrapper can only apply to a single variable", ())
+ERROR(property_with_wrapper_in_bad_context,none,
       "%select{|non-static |non-static }1property %0 declared inside "
-      "%select{a protocol|an extension|an enum}1 cannot have a delegate",
+      "%select{a protocol|an extension|an enum}1 cannot have a wrapper",
       (DeclName, int))
-ERROR(property_with_delegate_overrides,none,
-      "property %0 with attached delegate cannot override another property",
+ERROR(property_with_wrapper_overrides,none,
+      "property %0 with attached wrapper cannot override another property",
       (DeclName))
 
-ERROR(property_delegate_and_normal_init,none,
-      "property %0 with attached delegate cannot initialize both the "
-      "delegate type and the property", (DeclName))
-ERROR(property_delegate_init_without_initial_value, none,
-      "initializing property %0 with delegate %1 that lacks "
+ERROR(property_wrapper_and_normal_init,none,
+      "property %0 with attached wrapper cannot initialize both the "
+      "wrapper type and the property", (DeclName))
+ERROR(property_wrapper_init_without_initial_value, none,
+      "initializing property %0 with wrapper %1 that lacks "
       "an 'init(initialValue:)' initializer", (DeclName, Type))
-NOTE(property_delegate_direct_init,none,
-     "initialize the property delegate type directly with "
+NOTE(property_wrapper_direct_init,none,
+     "initialize the property wrapper type directly with "
      "'(...') on the attribute", ())
 
-ERROR(property_delegate_incompatible_unbound, none,
-      "property delegate type %0 must either specify all generic arguments "
+ERROR(property_wrapper_incompatible_unbound, none,
+      "property wrapper type %0 must either specify all generic arguments "
       "or require only a single generic argument", (Type))
 
-ERROR(property_delegate_type_access,none,
+ERROR(property_wrapper_type_access,none,
       "%select{%select{variable|constant}0|property}1 "
       "%select{must be declared %select{"
       "%select{private|fileprivate|internal|%error|%error}3|private or fileprivate}4"
       "|cannot be declared "
       "%select{in this context|fileprivate|internal|public|open}3}2 "
-      "because its property delegate type uses "
+      "because its property wrapper type uses "
       "%select{a private|a fileprivate|an internal|%error|%error}5 type",
       (bool, bool, bool, AccessLevel, bool, AccessLevel))
-ERROR(property_delegate_type_not_usable_from_inline,none,
-      "property delegate type referenced from a '@usableFromInline' "
+ERROR(property_wrapper_type_not_usable_from_inline,none,
+      "property wrapper type referenced from a '@usableFromInline' "
       "%select{%select{variable|constant}0|property}1 "
       "must be '@usableFromInline' or public",
       (bool, bool))

include/swift/AST/KnownIdentifiers.def

@@ -114,6 +114,7 @@ IDENTIFIER(WinSDK)
 IDENTIFIER(with)
 IDENTIFIER(withArguments)
 IDENTIFIER(withKeywordArguments)
+IDENTIFIER(wrapperValue)
 
 // Kinds of layout constraints
 IDENTIFIER_WITH_NAME(UnknownLayout, "_UnknownLayout")