Merge pull request #17238 from rjmccall/full-accessor-lists

Generalize accessor storage to preserve the original accessor list.

Author: rjmccall

include/swift/AST/Decl.h

@@ -3962,9 +3962,11 @@ enum class AccessorKind {
 #include "swift/AST/AccessorKinds.def"
 };
 
+const unsigned NumAccessorKinds = unsigned(AccessorKind::Last) + 1;
+
 static inline IntRange<AccessorKind> allAccessorKinds() {
   return IntRange<AccessorKind>(AccessorKind(0),
-                                AccessorKind(unsigned(AccessorKind::Last) + 1));
+                                AccessorKind(NumAccessorKinds));
 }
 
 /// The safety semantics of this addressor.
@@ -4121,66 +4123,66 @@ class AbstractStorageDecl : public ValueDecl {
     /// return the address at which the object is stored.
     ComputedWithMutableAddress,
   };
+
+  static const size_t MaxNumAccessors = 255;
 private:
   AbstractStorageDecl *OverriddenDecl;
 
-  struct GetSetRecord;
-  
-  /// This is stored immediately before the GetSetRecord.
-  struct alignas(1 << 3) AddressorRecord {
-    AccessorDecl *Address = nullptr;        // User-defined address accessor
-    AccessorDecl *MutableAddress = nullptr; // User-defined mutableAddress accessor
-
-    GetSetRecord *getGetSet() {
-      // Relies on not-strictly-portable ABI layout assumptions.
-      return reinterpret_cast<GetSetRecord*>(this+1);
-    }
-  };
-  void configureAddressorRecord(AddressorRecord *record,
-                               AccessorDecl *addressor, AccessorDecl *mutableAddressor);
+  /// A record of the accessors for the declaration.
+  class alignas(1 << 3) AccessorRecord final :
+      private llvm::TrailingObjects<AccessorRecord, AccessorDecl*> {
+    friend TrailingObjects;
+
+    using AccessorIndex = uint8_t;
+    static const AccessorIndex InvalidIndex = 0;
 
-  struct alignas(1 << 3) GetSetRecord {
     SourceRange Braces;
-    AccessorDecl *Get = nullptr;       // User-defined getter
-    AccessorDecl *Set = nullptr;       // User-defined setter
-    AccessorDecl *MaterializeForSet = nullptr; // optional materializeForSet accessor
+    AccessorIndex NumAccessors;
+
+    /// The storage capacity of this record for accessors.  Always includes
+    /// enough space for adding opaque accessors to the record, which are the
+    /// only accessors that should ever be added retroactively; hence this
+    /// field is only here for the purposes of safety checks.
+    AccessorIndex AccessorsCapacity;
+
+    /// Either 0, meaning there is no registered accessor of the given kind,
+    /// or the index+1 of the accessor in the accessors array.
+    AccessorIndex AccessorIndices[NumAccessorKinds];
+
+    AccessorRecord(SourceRange braces, ArrayRef<AccessorDecl*> accessors,
+                   AccessorIndex accessorsCapacity);
+  public:
+    static AccessorRecord *create(ASTContext &ctx, SourceRange braces,
+                                  ArrayRef<AccessorDecl*> accessors);
+
+    SourceRange getBracesRange() const { return Braces; }
+
+    inline AccessorDecl *getAccessor(AccessorKind kind) const;
 
-    AddressorRecord *getAddressors() {
-      // Relies on not-strictly-portable ABI layout assumptions.
-      return reinterpret_cast<AddressorRecord*>(this) - 1;
+    ArrayRef<AccessorDecl *> getAllAccessors() const {
+      return { getTrailingObjects<AccessorDecl*>(), NumAccessors };
     }
+
+    void addOpaqueAccessor(AccessorDecl *accessor);
+
+  private:
+    MutableArrayRef<AccessorDecl *> getAccessorsBuffer() {
+      return { getTrailingObjects<AccessorDecl*>(), NumAccessors };
+    }
+
+    bool registerAccessor(AccessorDecl *accessor, AccessorIndex index);
   };
-  void configureGetSetRecord(GetSetRecord *getSetRecord,
-                             AccessorDecl *getter, AccessorDecl *setter,
-                             AccessorDecl *materializeForSet);
-  void configureSetRecord(GetSetRecord *getSetInfo,
-                          AccessorDecl *setter,
-                          AccessorDecl *materializeForSet);
-
-  struct ObservingRecord : GetSetRecord {
-    AccessorDecl *WillSet = nullptr;   // willSet(value):
-    AccessorDecl *DidSet = nullptr;    // didSet:
-  };
-  void configureObservingRecord(ObservingRecord *record,
-                                AccessorDecl *willSet, AccessorDecl *didSet);
 
-  llvm::PointerIntPair<GetSetRecord*, 3, OptionalEnum<AccessLevel>> GetSetInfo;
+  llvm::PointerIntPair<AccessorRecord*, 3, OptionalEnum<AccessLevel>> Accessors;
   llvm::PointerIntPair<BehaviorRecord*, 3, OptionalEnum<AccessLevel>>
     BehaviorInfo;
 
-  ObservingRecord &getDidSetInfo() const {
-    assert(hasObservers());
-    return *static_cast<ObservingRecord*>(GetSetInfo.getPointer());
-  }
-  AddressorRecord &getAddressorInfo() const {
-    assert(hasAddressors());
-    return *GetSetInfo.getPointer()->getAddressors();
-  }
-
   void setStorageKind(StorageKindTy K) {
     Bits.AbstractStorageDecl.StorageKind = unsigned(K);
   }
 
+  void configureAccessor(AccessorDecl *accessor);
+
 protected:
   AbstractStorageDecl(DeclKind Kind, DeclContext *DC, DeclName Name,
                       SourceLoc NameLoc)
@@ -4308,55 +4310,26 @@ class AbstractStorageDecl : public ValueDecl {
     Bits.AbstractStorageDecl.IsSetterMutating = isMutating;
   }
 
-  AccessorDecl *getAccessorFunction(AccessorKind accessor) const;
-
-  /// \brief Push all of the accessor functions associated with this VarDecl
-  /// onto `decls`.
-  void getAllAccessorFunctions(SmallVectorImpl<Decl *> &decls) const;
+  AccessorDecl *getAccessorFunction(AccessorKind kind) const {
+    if (auto info = Accessors.getPointer())
+      return info->getAccessor(kind);
+    return nullptr;
+  }
 
-  /// \brief Turn this into a computed variable, providing a getter and setter.
-  void makeComputed(SourceLoc LBraceLoc, AccessorDecl *Get, AccessorDecl *Set,
-                    AccessorDecl *MaterializeForSet, SourceLoc RBraceLoc);
+  ArrayRef<AccessorDecl*> getAllAccessorFunctions() const {
+    if (const auto *info = Accessors.getPointer())
+      return info->getAllAccessors();
+    return {};
+  }
 
-  /// \brief Turn this into a computed object, providing a getter and a mutable
-  /// addressor.
-  void makeComputedWithMutableAddress(SourceLoc lbraceLoc,
-                                      AccessorDecl *getter,
-                                      AccessorDecl *setter,
-                                      AccessorDecl *materializeForSet,
-                                      AccessorDecl *mutableAddressor,
-                                      SourceLoc rbraceLoc);
+  void setAccessors(StorageKindTy storageKind,
+                    SourceLoc lbraceLoc, ArrayRef<AccessorDecl*> accessors,
+                    SourceLoc rbraceLoc);
 
   /// \brief Add trivial accessors to this Stored or Addressed object.
   void addTrivialAccessors(AccessorDecl *Get, AccessorDecl *Set,
                            AccessorDecl *MaterializeForSet);
 
-  /// \brief Turn this into a stored-with-observers var, providing the
-  /// didSet/willSet specifiers.
-  void makeStoredWithObservers(SourceLoc LBraceLoc, AccessorDecl *WillSet,
-                               AccessorDecl *DidSet, SourceLoc RBraceLoc);
-
-  /// \brief Turn this into an inherited-with-observers var, providing
-  /// the didSet/willSet specifiers.
-  void makeInheritedWithObservers(SourceLoc LBraceLoc, AccessorDecl *WillSet,
-                                  AccessorDecl *DidSet, SourceLoc RBraceLoc);
-
-  /// \brief Turn this into an addressed var.
-  void makeAddressed(SourceLoc LBraceLoc, AccessorDecl *Addressor,
-                     AccessorDecl *MutableAddressor,
-                     SourceLoc RBraceLoc);
-
-  /// \brief Turn this into an addressed var with observing accessors.
-  void makeAddressedWithObservers(SourceLoc LBraceLoc, AccessorDecl *Addressor,
-                                  AccessorDecl *MutableAddressor,
-                                  AccessorDecl *WillSet, AccessorDecl *DidSet,
-                                  SourceLoc RBraceLoc);
-
-  /// \brief Specify the synthesized get/set functions for a
-  /// StoredWithObservers or AddressedWithObservers var.  This is used by Sema.
-  void setObservingAccessors(AccessorDecl *Get, AccessorDecl *Set,
-                             AccessorDecl *MaterializeForSet);
-
   /// \brief Add a setter to an existing Computed var.
   ///
   /// This should only be used by the ClangImporter.
@@ -4370,39 +4343,30 @@ class AbstractStorageDecl : public ValueDecl {
   /// This should only be used by Sema.
   void setMaterializeForSetFunc(AccessorDecl *materializeForSet);
 
-  /// \brief Specify the braces range without adding accessors.
-  ///
-  /// This is used to record the braces range if the accessors were rejected.
-  void setInvalidBracesRange(SourceRange BracesRange);
-
   SourceRange getBracesRange() const {
-    if (auto info = GetSetInfo.getPointer())
-      return info->Braces;
+    if (auto info = Accessors.getPointer())
+      return info->getBracesRange();
     return SourceRange();
   }
 
   /// \brief Retrieve the getter used to access the value of this variable.
   AccessorDecl *getGetter() const {
-    if (auto info = GetSetInfo.getPointer())
-      return info->Get;
-    return nullptr;
+    return getAccessorFunction(AccessorKind::Get);
   }
 
   /// \brief Retrieve the setter used to mutate the value of this variable.
   AccessorDecl *getSetter() const {
-    if (auto info = GetSetInfo.getPointer())
-      return info->Set;
-    return nullptr;
+    return getAccessorFunction(AccessorKind::Set);
   }
 
   AccessLevel getSetterFormalAccess() const {
     assert(hasAccess());
-    assert(GetSetInfo.getInt().hasValue());
-    return GetSetInfo.getInt().getValue();
+    assert(Accessors.getInt().hasValue());
+    return Accessors.getInt().getValue();
   }
 
   void setSetterAccess(AccessLevel accessLevel) {
-    assert(!GetSetInfo.getInt().hasValue());
+    assert(!Accessors.getInt().hasValue());
     overwriteSetterAccess(accessLevel);
   }
 
@@ -4411,19 +4375,18 @@ class AbstractStorageDecl : public ValueDecl {
   /// \brief Retrieve the materializeForSet function, if this
   /// declaration has one.
   AccessorDecl *getMaterializeForSetFunc() const {
-    if (auto info = GetSetInfo.getPointer())
-      return info->MaterializeForSet;
-    return nullptr;
+    return getAccessorFunction(AccessorKind::MaterializeForSet);
   }
 
-  /// \brief Return the decl for the 'address' accessor if it
-  /// exists; this is only valid on a declaration with addressors.
-  AccessorDecl *getAddressor() const { return getAddressorInfo().Address; }
+  /// \brief Return the decl for the immutable addressor if it exists.
+  AccessorDecl *getAddressor() const {
+    return getAccessorFunction(AccessorKind::Address);
+  }
 
   /// \brief Return the decl for the 'mutableAddress' accessors if
   /// it exists; this is only valid on a declaration with addressors.
   AccessorDecl *getMutableAddressor() const {
-    return getAddressorInfo().MutableAddress;
+    return getAccessorFunction(AccessorKind::MutableAddress);
   }
 
   /// \brief Return the appropriate addressor for the given access kind.
@@ -4435,11 +4398,15 @@ class AbstractStorageDecl : public ValueDecl {
 
   /// \brief Return the decl for the willSet specifier if it exists, this is
   /// only valid on a declaration with Observing storage.
-  AccessorDecl *getWillSetFunc() const { return getDidSetInfo().WillSet; }
+  AccessorDecl *getWillSetFunc() const {
+    return getAccessorFunction(AccessorKind::WillSet);
+  }
 
   /// \brief Return the decl for the didSet specifier if it exists, this is
   /// only valid on a declaration with Observing storage.
-  AccessorDecl *getDidSetFunc() const { return getDidSetInfo().DidSet; }
+  AccessorDecl *getDidSetFunc() const {
+    return getAccessorFunction(AccessorKind::DidSet);
+  }
 
   /// Given that this is an Objective-C property or subscript declaration,
   /// produce its getter selector.
@@ -5777,6 +5744,16 @@ inline ParameterList **FuncDecl::getParameterListBuffer() {
   }
   return reinterpret_cast<ParameterList**>(static_cast<AccessorDecl*>(this)+1);
 }
+
+inline AccessorDecl *
+AbstractStorageDecl::AccessorRecord::getAccessor(AccessorKind kind) const {
+  if (auto optIndex = AccessorIndices[unsigned(kind)]) {
+    auto accessor = getAllAccessors()[optIndex - 1];
+    assert(accessor && accessor->getAccessorKind() == kind);
+    return accessor;
+  }
+  return nullptr;
+}
 
 /// \brief This represents a 'case' declaration in an 'enum', which may declare
 /// one or more individual comma-separated EnumElementDecls.
@@ -6652,7 +6629,7 @@ ::operator()(Decl *decl) const {
 
 inline void
 AbstractStorageDecl::overwriteSetterAccess(AccessLevel accessLevel) {
-  GetSetInfo.setInt(accessLevel);
+  Accessors.setInt(accessLevel);
   if (auto setter = getSetter())
     setter->overwriteAccess(accessLevel);
   if (auto materializeForSet = getMaterializeForSetFunc())

include/swift/Parse/Parser.h

@@ -878,6 +878,7 @@ class Parser {
 
   struct ParsedAccessors {
     SourceLoc LBLoc, RBLoc;
+    SmallVector<AccessorDecl*, 16> Accessors;
 
 #define ACCESSOR(ID) AccessorDecl *ID = nullptr;
 #include "swift/AST/AccessorKinds.def"
@@ -887,6 +888,17 @@ class Parser {
                 const DeclAttributes &attrs,
                 TypeLoc elementTy, ParameterList *indices,
                 SmallVectorImpl<Decl *> &decls);
+
+    AbstractStorageDecl::StorageKindTy
+    classify(Parser &P, AbstractStorageDecl *storage, bool invalid,
+             ParseDeclOptions flags, SourceLoc staticLoc,
+             const DeclAttributes &attrs,
+             TypeLoc elementTy, ParameterList *indices);
+
+    /// Add an accessor.  If there's an existing accessor of this kind,
+    /// return it.  The new accessor is still remembered but will be
+    /// ignored.
+    AccessorDecl *add(AccessorDecl *accessor);
   };
 
   void parseAccessorAttributes(DeclAttributes &Attributes);
@@ -898,15 +910,14 @@ class Parser {
                        ParsedAccessors &accessors,
                        AbstractStorageDecl *storage,
                        SourceLoc &LastValidLoc,
-                       SourceLoc StaticLoc, SourceLoc VarLBLoc,
-                       SmallVectorImpl<Decl *> &Decls);
+                       SourceLoc StaticLoc, SourceLoc VarLBLoc);
   bool parseGetSet(ParseDeclOptions Flags,
                    GenericParamList *GenericParams,
                    ParameterList *Indices,
                    TypeLoc ElementTy,
                    ParsedAccessors &accessors,
                    AbstractStorageDecl *storage,
-                   SourceLoc StaticLoc, SmallVectorImpl<Decl *> &Decls);
+                   SourceLoc StaticLoc);
   void recordAccessors(AbstractStorageDecl *storage, ParseDeclOptions flags,
                        TypeLoc elementTy, const DeclAttributes &attrs,
                        SourceLoc staticLoc, ParsedAccessors &accessors);