[SE-0258] Implement basic support for property wrapper composition.

When multiple property wrapper attributes are provided on a declaration,
compose them outside-in to form a composite property wrapper type. For
example,

  @A @b @C var foo = 17

will produce

  var $foo = A(initialValue: B(initialValue: C(initialValue: 17)))

and foo's getter/setter will access "foo.value.value.value".

(cherry picked from commit 82ed5e9)
(cherry picked from commit 26f0b74)

Author: DougGregor

include/swift/AST/Decl.h

@@ -5078,26 +5078,39 @@ class VarDecl : public AbstractStorageDecl {
     Bits.VarDecl.IsREPLVar = IsREPLVar;
   }
 
-  /// Retrieve the custom attribute that attaches a property wrapper to this
-  /// property.
-  CustomAttr *getAttachedPropertyWrapper() const;
+  /// Retrieve the custom attributes that attach property wrappers to this
+  /// property. The returned list contains all of the attached property wrapper attributes in source order,
+  /// which means the outermost wrapper attribute is provided first.
+  llvm::TinyPtrVector<CustomAttr *> getAttachedPropertyWrappers() const;
 
+  /// Whether this property has any attached property wrappers.
+  bool hasAttachedPropertyWrapper() const;
+  
+  /// Whether all of the attached property wrappers have an init(initialValue:) initializer.
+  bool allAttachedPropertyWrappersHaveInitialValueInit() const;
+  
   /// Retrieve the type of the attached property wrapper as a contextual
   /// type.
   ///
+  /// \param index Which property wrapper type is being computed, where 0
+  /// indicates the first (outermost) attached property wrapper.
+  ///
   /// \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 getAttachedPropertyWrapperType() const;
+  Type getAttachedPropertyWrapperType(unsigned index) const;
 
   /// Retrieve information about the attached property wrapper type.
-  PropertyWrapperTypeInfo getAttachedPropertyWrapperTypeInfo() const;
+  ///
+  /// \param i Which attached property wrapper type is being queried, where 0 is the outermost (first)
+  /// attached property wrapper type.
+  PropertyWrapperTypeInfo getAttachedPropertyWrapperTypeInfo(unsigned i) const;
 
   /// Retrieve the fully resolved attached property wrapper type.
   ///
   /// This type will be the fully-resolved form of
-  /// \c getAttachedPropertyWrapperType(), which will not contain any
+  /// \c getAttachedPropertyWrapperType(0), which will not contain any
   /// unbound generic types. It will be the type of the backing property.
   Type getPropertyWrapperBackingPropertyType() const;
 
@@ -5111,8 +5124,8 @@ class VarDecl : public AbstractStorageDecl {
   ///
   /// The backing storage property will be a stored property of the
   /// wrapper's type. This will be equivalent to
-  /// \c getAttachedPropertyWrapperType() when it is fully-specified;
-  /// if \c getAttachedPropertyWrapperType() involves an unbound
+  /// \c getAttachedPropertyWrapperType(0) when it is fully-specified;
+  /// if \c getAttachedPropertyWrapperType(0) involves an unbound
   /// generic type, the backing storage property will be the appropriate
   /// bound generic version.
   VarDecl *getPropertyWrapperBackingProperty() const;

include/swift/AST/DiagnosticsSema.def

@@ -4391,11 +4391,6 @@ ERROR(property_wrapper_attribute_not_on_property, none,
 NOTE(property_wrapper_declared_here,none,
      "property wrapper type %0 declared here", (DeclName))
 
-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_wrapper_local,none,
       "property wrappers are not yet supported on local properties", ())
 ERROR(property_wrapper_let, none,

include/swift/AST/TypeCheckRequests.h

@@ -420,10 +420,10 @@ class PropertyWrapperTypeInfoRequest
 
 /// Request the nominal type declaration to which the given custom attribute
 /// refers.
-class AttachedPropertyWrapperRequest :
-    public SimpleRequest<AttachedPropertyWrapperRequest,
+class AttachedPropertyWrappersRequest :
+    public SimpleRequest<AttachedPropertyWrappersRequest,
                          CacheKind::Cached,
-                         CustomAttr *,
+                         llvm::TinyPtrVector<CustomAttr *>,
                          VarDecl *> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -432,7 +432,7 @@ class AttachedPropertyWrapperRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  llvm::Expected<CustomAttr *>
+  llvm::Expected<llvm::TinyPtrVector<CustomAttr *>>
   evaluate(Evaluator &evaluator, VarDecl *) const;
 
 public:
@@ -450,7 +450,7 @@ class AttachedPropertyWrapperTypeRequest :
     public SimpleRequest<AttachedPropertyWrapperTypeRequest,
                          CacheKind::Cached,
                          Type,
-                         VarDecl *> {
+                         VarDecl *, unsigned> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -459,7 +459,7 @@ class AttachedPropertyWrapperTypeRequest :
 
   // Evaluation.
   llvm::Expected<Type>
-  evaluate(Evaluator &evaluator, VarDecl *var) const;
+  evaluate(Evaluator &evaluator, VarDecl *var, unsigned i) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -25,7 +25,7 @@ SWIFT_TYPEID(USRGenerationRequest)
 SWIFT_TYPEID(DefaultTypeRequest)
 SWIFT_TYPEID(MangleLocalTypeDeclRequest)
 SWIFT_TYPEID(PropertyWrapperTypeInfoRequest)
-SWIFT_TYPEID(AttachedPropertyWrapperRequest)
+SWIFT_TYPEID(AttachedPropertyWrappersRequest)
 SWIFT_TYPEID(AttachedPropertyWrapperTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyInfoRequest)

include/swift/Basic/AnyValue.h

@@ -21,6 +21,7 @@
 #include "swift/Basic/SimpleDisplay.h"
 #include "swift/Basic/TypeID.h"
 #include "llvm/ADT/PointerUnion.h"  // to define hash_value
+#include "llvm/ADT/TinyPtrVector.h"
 
 namespace llvm {
   // FIXME: Belongs in LLVM itself
@@ -146,6 +147,26 @@ class AnyValue {
 
 } // end namespace swift
 
+namespace llvm {
+  template<typename T>
+  bool operator==(const TinyPtrVector<T> &lhs, const TinyPtrVector<T> &rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    
+    for (unsigned i = 0, n = lhs.size(); i != n; ++i) {
+      if (lhs[i] != rhs[i])
+        return false;
+    }
+    
+    return true;
+  }
+  
+  template<typename T>
+  bool operator!=(const TinyPtrVector<T> &lhs, const TinyPtrVector<T> &rhs) {
+    return !(lhs == rhs);
+  }
+} // end namespace llvm
+
 #endif //
 
 

include/swift/Basic/SimpleDisplay.h

@@ -19,6 +19,7 @@
 #ifndef SWIFT_BASIC_SIMPLE_DISPLAY_H
 #define SWIFT_BASIC_SIMPLE_DISPLAY_H
 
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/raw_ostream.h"
 #include <tuple>
 #include <type_traits>
@@ -92,6 +93,20 @@ namespace swift {
                       const std::tuple<Types...> &value) {
     simple_display_tuple<0>(out, value);
   }
+  
+  template<typename T>
+  void simple_display(llvm::raw_ostream &out,
+                      const llvm::TinyPtrVector<T> &vector) {
+    out << "{";
+    bool first = true;
+    for (const T &value : vector) {
+      if (first) first = false;
+      else out << ", ";
+      
+      simple_display(out, value);
+    }
+    out << "}";
+  }
 }
 
 #endif // SWIFT_BASIC_SIMPLE_DISPLAY_H

lib/AST/Decl.cpp

@@ -1378,10 +1378,9 @@ bool PatternBindingEntry::isInitialized() const {
 
   // Initialized via a property wrapper.
   if (auto var = getPattern()->getSingleVar()) {
-    if (auto customAttr = var->getAttachedPropertyWrapper()) {
-      if (customAttr->getArg() != nullptr)
-        return true;
-    }
+    auto customAttrs = var->getAttachedPropertyWrappers();
+    if (customAttrs.size() > 0 && customAttrs[0]->getArg() != nullptr)
+      return true;
   }
 
   return false;
@@ -1571,10 +1570,10 @@ bool PatternBindingDecl::isDefaultInitializable(unsigned i) const {
   if (entry.isInitialized())
     return true;
 
-  // If it has an attached property wrapper that vends an `init()`, use that
+  // If the outermost attached property wrapper vends an `init()`, use that
   // for default initialization.
   if (auto singleVar = getSingleVar()) {
-    if (auto wrapperInfo = singleVar->getAttachedPropertyWrapperTypeInfo()) {
+    if (auto wrapperInfo = singleVar->getAttachedPropertyWrapperTypeInfo(0)) {
       if (wrapperInfo.defaultInit)
         return true;
     }
@@ -5252,12 +5251,12 @@ static bool isBackingStorageForDeclaredProperty(const VarDecl *var) {
   return name.str().startswith("$__lazy_storage_$_");
 }
 
-/// Whether the given variable
+/// Whether the given variable is a delcared property that has separate backing storage.
 static bool isDeclaredPropertyWithBackingStorage(const VarDecl *var) {
   if (var->getAttrs().hasAttribute<LazyAttr>())
     return true;
 
-  if (var->getAttachedPropertyWrapper())
+  if (var->hasAttachedPropertyWrapper())
     return true;
 
   return false;
@@ -5298,7 +5297,7 @@ bool VarDecl::isMemberwiseInitialized(bool preferDeclaredProperties) const {
   if (auto origWrapped = getOriginalWrappedProperty())
     origVar = origWrapped;
   if (origVar->getFormalAccess() < AccessLevel::Internal &&
-      origVar->getAttachedPropertyWrapper() &&
+      origVar->hasAttachedPropertyWrapper() &&
       (origVar->isParentInitialized() ||
        (origVar->getParentPatternBinding() &&
         origVar->getParentPatternBinding()->isDefaultInitializable())))
@@ -5340,22 +5339,39 @@ StaticSpellingKind AbstractStorageDecl::getCorrectStaticSpelling() const {
   return getCorrectStaticSpellingForDecl(this);
 }
 
-CustomAttr *VarDecl::getAttachedPropertyWrapper() const {
+llvm::TinyPtrVector<CustomAttr *> VarDecl::getAttachedPropertyWrappers() const {
   auto &ctx = getASTContext();
   if (!ctx.getLazyResolver())
-    return nullptr;
+    return { };
 
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
-                           AttachedPropertyWrapperRequest{mutableThis},
-                           nullptr);
+                           AttachedPropertyWrappersRequest{mutableThis},
+                           { });
 }
 
-PropertyWrapperTypeInfo VarDecl::getAttachedPropertyWrapperTypeInfo() const {
-  auto attr = getAttachedPropertyWrapper();
-  if (!attr)
-    return PropertyWrapperTypeInfo();
+/// Whether this property has any attached property wrappers.
+bool VarDecl::hasAttachedPropertyWrapper() const {
+  return !getAttachedPropertyWrappers().empty();
+}
+
+/// Whether all of the attached property wrappers have an init(initialValue:) initializer.
+bool VarDecl::allAttachedPropertyWrappersHaveInitialValueInit() const {
+  for (unsigned i : indices(getAttachedPropertyWrappers())) {
+    if (!getAttachedPropertyWrapperTypeInfo(i).initialValueInit)
+      return false;
+  }
+  
+  return true;
+}
 
+PropertyWrapperTypeInfo
+VarDecl::getAttachedPropertyWrapperTypeInfo(unsigned i) const {
+  auto attrs = getAttachedPropertyWrappers();
+  if (i >= attrs.size())
+    return PropertyWrapperTypeInfo();
+  
+  auto attr = attrs[i];
   auto dc = getDeclContext();
   ASTContext &ctx = getASTContext();
   auto nominal = evaluateOrDefault(
@@ -5366,12 +5382,13 @@ PropertyWrapperTypeInfo VarDecl::getAttachedPropertyWrapperTypeInfo() const {
   return nominal->getPropertyWrapperTypeInfo();
 }
 
-Type VarDecl::getAttachedPropertyWrapperType() const {
+Type VarDecl::getAttachedPropertyWrapperType(unsigned index) const {
   auto &ctx = getASTContext();
   auto mutableThis = const_cast<VarDecl *>(this);
-  return evaluateOrDefault(ctx.evaluator,
-                           AttachedPropertyWrapperTypeRequest{mutableThis},
-                           Type());
+  return evaluateOrDefault(
+      ctx.evaluator,
+      AttachedPropertyWrapperTypeRequest{mutableThis, index},
+      Type());
 }
 
 Type VarDecl::getPropertyWrapperBackingPropertyType() const {
@@ -5397,8 +5414,8 @@ VarDecl *VarDecl::getPropertyWrapperBackingProperty() const {
 }
 
 bool VarDecl::isPropertyWrapperInitializedWithInitialValue() const {
-  auto customAttr = getAttachedPropertyWrapper();
-  if (!customAttr)
+  auto customAttrs = getAttachedPropertyWrappers();
+  if (customAttrs.empty())
     return false;
 
   auto *PBD = getParentPatternBinding();
@@ -5410,24 +5427,23 @@ bool VarDecl::isPropertyWrapperInitializedWithInitialValue() const {
   if (PBD->getPatternList()[0].getEqualLoc().isValid())
     return true;
 
-  // If there was an initializer on the attribute itself, initialize
+  // If there was an initializer on the outermost wrapper, initialize
   // via the full wrapper.
-  if (customAttr->getArg() != nullptr)
+  if (customAttrs[0]->getArg() != nullptr)
     return false;
 
   // Default initialization does not use a value.
-  auto wrapperTypeInfo = getAttachedPropertyWrapperTypeInfo();
-  if (wrapperTypeInfo.defaultInit)
+  if (getAttachedPropertyWrapperTypeInfo(0).defaultInit)
     return false;
 
-  // There is no initializer, so the initialization form depends on
-  // whether the property wrapper type has an init(initialValue:).
-  return wrapperTypeInfo.initialValueInit != nullptr;
+  // If all property wrappers have an initialValue initializer, the property
+  // wrapper will be initialized that way.
+  return allAttachedPropertyWrappersHaveInitialValueInit();
 }
 
 bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
-  auto customAttr = getAttachedPropertyWrapper();
-  if (!customAttr)
+  auto customAttrs = getAttachedPropertyWrappers();
+  if (customAttrs.empty())
     return false;
 
   auto *PBD = getParentPatternBinding();
@@ -5439,15 +5455,14 @@ bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
   if (PBD->getPatternList()[0].getEqualLoc().isValid())
     return true;
 
-  // If there was an initializer on the attribute itself, initialize
+  // If there was an initializer on the outermost wrapper, initialize
   // via the full wrapper.
-  if (customAttr->getArg() != nullptr)
+  if (customAttrs[0]->getArg() != nullptr)
     return false;
 
-  // There is no initializer, so the initialization form depends on
-  // whether the property wrapper type has an init(initialValue:).
-  auto wrapperTypeInfo = getAttachedPropertyWrapperTypeInfo();
-  return wrapperTypeInfo.initialValueInit != nullptr;
+  // If all property wrappers have an initialValue initializer, the property
+  // wrapper will be initialized that way.
+  return allAttachedPropertyWrappersHaveInitialValueInit();
 }
 
 Identifier VarDecl::getObjCPropertyName() const {
@@ -5699,9 +5714,8 @@ void ParamDecl::setDefaultArgumentInitContext(Initializer *initContext) {
 }
 
 Expr *swift::findOriginalPropertyWrapperInitialValue(VarDecl *var,
-                                                      Expr *init) {
-  auto attr = var->getAttachedPropertyWrapper();
-  assert(attr && "No attached property wrapper?");
+                                                     Expr *init) {
+  auto attr = var->getAttachedPropertyWrappers().front();
 
   // Direct initialization implies no original initial value.
   if (attr->getArg())
@@ -5755,7 +5769,9 @@ ParamDecl::getDefaultValueStringRepresentation(
     auto var = getStoredProperty();
 
     if (auto original = var->getOriginalWrappedProperty()) {
-      if (auto attr = original->getAttachedPropertyWrapper()) {
+      auto wrapperAttrs = original->getAttachedPropertyWrappers();
+      if (wrapperAttrs.size() > 0) {
+        auto attr = wrapperAttrs.front();
         if (auto arg = attr->getArg()) {
           SourceRange fullRange(attr->getTypeLoc().getSourceRange().Start,
                                 arg->getEndLoc());