AST: Remove owning addressors

docs/ABI/Mangling.rst

@@ -289,8 +289,8 @@ Entities
   ACCESSOR ::= 'p'                           // pseudo accessor referring to the storage itself
 
   ADDRESSOR-KIND ::= 'u'                     // unsafe addressor (no owner)
-  ADDRESSOR-KIND ::= 'O'                     // owning addressor (non-native owner)
-  ADDRESSOR-KIND ::= 'o'                     // owning addressor (native owner)
+  ADDRESSOR-KIND ::= 'O'                     // owning addressor (non-native owner), not used anymore
+  ADDRESSOR-KIND ::= 'o'                     // owning addressor (native owner), not used anymore
   ADDRESSOR-KIND ::= 'p'                     // pinning addressor (native owner), not used anymore
 
   decl-name ::= identifier

include/swift/AST/ASTMangler.h

@@ -92,7 +92,6 @@ class ASTMangler : public Mangler {
                                           bool isDestroyer, SymbolKind SKind);
 
   std::string mangleAccessorEntity(AccessorKind kind,
-                                   AddressorKind addressorKind,
                                    const AbstractStorageDecl *decl,
                                    bool isStatic,
                                    SymbolKind SKind);
@@ -162,7 +161,6 @@ class ASTMangler : public Mangler {
   std::string mangleDeclAsUSR(const ValueDecl *Decl, StringRef USRPrefix);
 
   std::string mangleAccessorEntityAsUSR(AccessorKind kind,
-                                        AddressorKind addressorKind,
                                         const AbstractStorageDecl *decl,
                                         StringRef USRPrefix);
 

include/swift/AST/AccessorKinds.def

@@ -73,36 +73,31 @@
 #define COROUTINE_ACCESSOR(ID, KEYWORD) OPAQUE_ACCESSOR(ID, KEYWORD)
 #endif
 
-/// ANY_ADDRESSOR(ACCESSOR_ID, ADDRESSOR_ID, KEYWORD)
+/// ANY_ADDRESSOR(ID, KEYWORD)
 ///   The given keyword corresponds to an addressor of the given kind.
 ///
-///   Defaults to ACCESSOR_KEYWORD(KEYWORD) if that is defined; otherwise
-///   defaults to nothing.
+///   Defaults to SINGLETON_ACCESSOR(ID, KEYWORD).
 #ifndef ANY_ADDRESSOR
-#if defined(ACCESSOR_KEYWORD)
-#define ANY_ADDRESSOR(ACCESSOR_ID, ADDRESSOR_ID, KEYWORD) \
-  ACCESSOR_KEYWORD(KEYWORD)
-#else
-#define ANY_ADDRESSOR(ACCESSOR_ID, ADDRESSOR_ID, KEYWORD)
-#endif
+#define ANY_ADDRESSOR(ID, KEYWORD) \
+  SINGLETON_ACCESSOR(ID, KEYWORD)
 #endif
 
-/// IMMUTABLE_ADDRESSOR(ADDRESSOR_ID, KEYWORD)
+/// IMMUTABLE_ADDRESSOR(ID, KEYWORD)
 ///   The given keyword corresponds to an immutable addressor of the given kind.
 ///
-///   DEfaults to ANY_ADDRESSOR(Address, ADDRESSOR_ID, KEYWORD).
+///   DEfaults to ANY_ADDRESSOR(ID, KEYWORD).
 #ifndef IMMUTABLE_ADDRESSOR
-#define IMMUTABLE_ADDRESSOR(ADDRESSOR_ID, KEYWORD) \
-  ANY_ADDRESSOR(Address, ADDRESSOR_ID, KEYWORD)
+#define IMMUTABLE_ADDRESSOR(ID, KEYWORD) \
+  ANY_ADDRESSOR(ID, KEYWORD)
 #endif
 
-/// MUTABLE_ADDRESSOR(ADDRESSOR_ID, KEYWORD)
+/// MUTABLE_ADDRESSOR(ID, KEYWORD)
 ///   The given keyword corresponds to a mutable addressor of the given kind.
 ///
-///   DEfaults to ANY_ADDRESSOR(MutableAddress, ADDRESSOR_ID, KEYWORD).
+///   DEfaults to ANY_ADDRESSOR(ID, KEYWORD).
 #ifndef MUTABLE_ADDRESSOR
-#define MUTABLE_ADDRESSOR(ADDRESSOR_ID, KEYWORD) \
-  ANY_ADDRESSOR(MutableAddress, ADDRESSOR_ID, KEYWORD)
+#define MUTABLE_ADDRESSOR(ID, KEYWORD) \
+  ANY_ADDRESSOR(ID, KEYWORD)
 #endif
 
 // Suppress entries for accessors which can't be written in source code.
@@ -167,11 +162,7 @@ OBSERVING_ACCESSOR(DidSet, didSet)
 /// Addressors are a way of proving more efficient access to storage
 /// when it is already stored in memory (but not as a stored member
 /// of the type).
-ACCESSOR(Address)
-
-IMMUTABLE_ADDRESSOR(Unsafe, unsafeAddress)
-IMMUTABLE_ADDRESSOR(Owning, addressWithOwner)
-IMMUTABLE_ADDRESSOR(NativeOwning, addressWithNativeOwner)
+IMMUTABLE_ADDRESSOR(Address, unsafeAddress)
 
 /// This is a mutableAddress-family accessor: a function that is
 /// called when the storage is modified and which works by returning
@@ -181,11 +172,7 @@ IMMUTABLE_ADDRESSOR(NativeOwning, addressWithNativeOwner)
 /// Addressors are a way of proving more efficient access to storage
 /// when it is already stored in memory (but not as a stored member
 /// of the type).
-ACCESSOR(MutableAddress)
-
-MUTABLE_ADDRESSOR(Unsafe, unsafeMutableAddress)
-MUTABLE_ADDRESSOR(Owning, mutableAddressWithOwner)
-MUTABLE_ADDRESSOR(NativeOwning, mutableAddressWithNativeOwner)
+MUTABLE_ADDRESSOR(MutableAddress, unsafeMutableAddress)
 
 #ifdef LAST_ACCESSOR
 LAST_ACCESSOR(MutableAddress)

include/swift/AST/Decl.h

@@ -431,12 +431,9 @@ class alignas(1 << DeclAlignInBits) Decl {
     SelfAccess : 2
   );
 
-  SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4+3,
+  SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4,
     /// The kind of accessor this is.
-    AccessorKind : 4,
-
-    /// The kind of addressor this is.
-    AddressorKind : 3
+    AccessorKind : 4
   );
 
   SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 3+2+2+1,
@@ -5694,8 +5691,7 @@ class AccessorDecl final : public FuncDecl {
   AbstractStorageDecl *Storage;
 
   AccessorDecl(SourceLoc declLoc, SourceLoc accessorKeywordLoc,
-               AccessorKind accessorKind, AddressorKind addressorKind,
-               AbstractStorageDecl *storage,
+               AccessorKind accessorKind, AbstractStorageDecl *storage,
                SourceLoc staticLoc, StaticSpellingKind staticSpelling,
                bool throws, SourceLoc throwsLoc,
                unsigned numParameterLists, GenericParamList *genericParams,
@@ -5707,14 +5703,12 @@ class AccessorDecl final : public FuncDecl {
       AccessorKeywordLoc(accessorKeywordLoc),
       Storage(storage) {
     Bits.AccessorDecl.AccessorKind = unsigned(accessorKind);
-    Bits.AccessorDecl.AddressorKind = unsigned(addressorKind);
   }
 
   static AccessorDecl *createImpl(ASTContext &ctx,
                                   SourceLoc declLoc,
                                   SourceLoc accessorKeywordLoc,
                                   AccessorKind accessorKind,
-                                  AddressorKind addressorKind,
                                   AbstractStorageDecl *storage,
                                   SourceLoc staticLoc,
                                   StaticSpellingKind staticSpelling,
@@ -5728,7 +5722,6 @@ class AccessorDecl final : public FuncDecl {
                               SourceLoc declLoc,
                               SourceLoc accessorKeywordLoc,
                               AccessorKind accessorKind,
-                              AddressorKind addressorKind,
                               AbstractStorageDecl *storage,
                               SourceLoc staticLoc,
                               StaticSpellingKind staticSpelling,
@@ -5739,7 +5732,6 @@ class AccessorDecl final : public FuncDecl {
   static AccessorDecl *create(ASTContext &ctx, SourceLoc declLoc,
                               SourceLoc accessorKeywordLoc,
                               AccessorKind accessorKind,
-                              AddressorKind addressorKind,
                               AbstractStorageDecl *storage,
                               SourceLoc staticLoc,
                               StaticSpellingKind staticSpelling,
@@ -5759,10 +5751,6 @@ class AccessorDecl final : public FuncDecl {
     return AccessorKind(Bits.AccessorDecl.AccessorKind);
   }
 
-  AddressorKind getAddressorKind() const {
-    return AddressorKind(Bits.AccessorDecl.AddressorKind);
-  }
-
   bool isGetter() const { return getAccessorKind() == AccessorKind::Get; }
   bool isSetter() const { return getAccessorKind() == AccessorKind::Set; }
   bool isAnyAddressor() const {

include/swift/AST/StorageImpl.h

@@ -54,20 +54,6 @@ static inline IntRange<AccessorKind> allAccessorKinds() {
                                 AccessorKind(NumAccessorKinds));
 }
 
-/// The safety semantics of this addressor.
-enum class AddressorKind : uint8_t {
-  /// \brief This is not an addressor.
-  NotAddressor,
-  /// \brief This is an unsafe addressor; it simply returns an address.
-  Unsafe,
-  /// \brief This is an owning addressor; it returns an AnyObject
-  /// which should be released when the caller is done with the object.
-  Owning,
-  /// \brief This is an owning addressor; it returns a Builtin.NativeObject
-  /// which should be released when the caller is done with the object.
-  NativeOwning,
-};
-
 /// Whether an access to storage is for reading, writing, or both.
 enum class AccessKind : uint8_t {
   /// The access is just to read the current value.

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 464; // Last change: simplify GenericParamLists
+const uint16_t SWIFTMODULE_VERSION_MINOR = 465; // Last change: Remove owning addressors
 
 using DeclIDField = BCFixed<31>;
 
@@ -287,13 +287,6 @@ enum MetatypeRepresentation : uint8_t {
 };
 using MetatypeRepresentationField = BCFixed<2>;
 
-// These IDs must \em not be renumbered or reordered without incrementing
-// the module version.
-enum class AddressorKind : uint8_t {
-  NotAddressor, Unsafe, Owning, NativeOwning
-};
-using AddressorKindField = BCFixed<3>;
-
 // These IDs must \em not be renumbered or reordered without incrementing
 // the module version.
 enum class SelfAccessKind : uint8_t {
@@ -1082,7 +1075,6 @@ namespace decls_block {
     DeclIDField,  // overridden function
     DeclIDField,  // AccessorStorageDecl
     AccessorKindField, // accessor kind
-    AddressorKindField, // addressor kind
     AccessLevelField, // access level
     BCFixed<1>,   // requires a new vtable slot
     BCFixed<1>,   // default argument resilience expansion

lib/AST/ASTDumper.cpp

@@ -316,8 +316,6 @@ static StringRef getAccessorKindString(AccessorKind value) {
 #define SINGLETON_ACCESSOR(ID, KEYWORD) \
   case AccessorKind::ID: return #KEYWORD;
 #include "swift/AST/AccessorKinds.def"
-  case AccessorKind::Address: return "address";
-  case AccessorKind::MutableAddress: return "mutableAddress";
   }
 
   llvm_unreachable("Unhandled AccessorKind in switch.");

lib/AST/ASTMangler.cpp

@@ -45,8 +45,7 @@
 using namespace swift;
 using namespace swift::Mangle;
 
-static StringRef getCodeForAccessorKind(AccessorKind kind,
-                                        AddressorKind addressorKind) {
+static StringRef getCodeForAccessorKind(AccessorKind kind) {
   switch (kind) {
   case AccessorKind::Get:
     return "g";
@@ -62,29 +61,9 @@ static StringRef getCodeForAccessorKind(AccessorKind kind,
     return "M";
   case AccessorKind::Address:
     // 'l' is for location. 'A' was taken.
-    switch (addressorKind) {
-    case AddressorKind::NotAddressor:
-      llvm_unreachable("bad combo");
-    case AddressorKind::Unsafe:
-      return "lu";
-    case AddressorKind::Owning:
-      return "lO";
-    case AddressorKind::NativeOwning:
-      return "lo";
-    }
-    llvm_unreachable("bad addressor kind");
+    return "lu";
   case AccessorKind::MutableAddress:
-    switch (addressorKind) {
-    case AddressorKind::NotAddressor:
-      llvm_unreachable("bad combo");
-    case AddressorKind::Unsafe:
-      return "au";
-    case AddressorKind::Owning:
-      return "aO";
-    case AddressorKind::NativeOwning:
-      return "ao";
-    }
-    llvm_unreachable("bad addressor kind");
+    return "au";
   }
   llvm_unreachable("bad accessor kind");
 }
@@ -139,13 +118,11 @@ std::string ASTMangler::mangleIVarInitDestroyEntity(const ClassDecl *decl,
 }
 
 std::string ASTMangler::mangleAccessorEntity(AccessorKind kind,
-                                             AddressorKind addressorKind,
                                              const AbstractStorageDecl *decl,
                                              bool isStatic,
                                              SymbolKind SKind) {
   beginMangling();
-  appendAccessorEntity(getCodeForAccessorKind(kind, addressorKind), decl,
-                       isStatic);
+  appendAccessorEntity(getCodeForAccessorKind(kind), decl, isStatic);
   appendSymbolKind(SKind);
   return finalize();
 }
@@ -513,14 +490,12 @@ std::string ASTMangler::mangleDeclAsUSR(const ValueDecl *Decl,
 }
 
 std::string ASTMangler::mangleAccessorEntityAsUSR(AccessorKind kind,
-                                                  AddressorKind addressorKind,
                                                   const AbstractStorageDecl *decl,
                                                   StringRef USRPrefix) {
   beginManglingWithoutPrefix();
   llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
   Buffer << USRPrefix;
-  appendAccessorEntity(getCodeForAccessorKind(kind, addressorKind), decl,
-                       /*isStatic*/ false);
+  appendAccessorEntity(getCodeForAccessorKind(kind), decl, /*isStatic*/ false);
   // We have a custom prefix, so finalize() won't verify for us. Do it manually.
   verify(Storage.str().drop_front(USRPrefix.size()));
   return finalize();
@@ -2224,8 +2199,7 @@ void ASTMangler::appendEntity(const ValueDecl *decl) {
   // declaration.
   if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
     return appendAccessorEntity(
-        getCodeForAccessorKind(accessor->getAccessorKind(),
-                               accessor->getAddressorKind()),
+        getCodeForAccessorKind(accessor->getAccessorKind()),
         accessor->getStorage(), accessor->isStatic());
   }
 

lib/AST/ASTPrinter.cpp

@@ -1595,26 +1595,6 @@ static StringRef getAccessorLabel(AccessorDecl *accessor) {
   case AccessorKind::ID: return #KEYWORD;
 #define ACCESSOR(ID)
 #include "swift/AST/AccessorKinds.def"
-
-  case AccessorKind::Address:
-    switch (accessor->getAddressorKind()) {
-    case AddressorKind::NotAddressor: llvm_unreachable("bad combination");
-#define IMMUTABLE_ADDRESSOR(ID, KEYWORD) \
-    case AddressorKind::ID: return #KEYWORD;
-#define ACCESSOR(ID)
-#include "swift/AST/AccessorKinds.def"
-    }
-    llvm_unreachable("bad addressor kind");
-
-  case AccessorKind::MutableAddress:
-    switch (accessor->getAddressorKind()) {
-    case AddressorKind::NotAddressor: llvm_unreachable("bad combination");
-#define MUTABLE_ADDRESSOR(ID, KEYWORD) \
-    case AddressorKind::ID: return #KEYWORD;
-#define ACCESSOR(ID)
-#include "swift/AST/AccessorKinds.def"
-    }
-    llvm_unreachable("bad addressor kind");
   }
   llvm_unreachable("bad accessor kind");
 }

lib/AST/ASTVerifier.cpp

@@ -3172,28 +3172,6 @@ class Verifier : public ASTWalker {
         abort();
       }
 
-      switch (FD->getAccessorKind()) {
-      case AccessorKind::Get:
-      case AccessorKind::Set:
-      case AccessorKind::WillSet:
-      case AccessorKind::DidSet:
-      case AccessorKind::Read:
-      case AccessorKind::Modify:
-        if (FD->getAddressorKind() != AddressorKind::NotAddressor) {
-          Out << "non-addressor accessor has an addressor kind\n";
-          abort();
-        }
-        break;
-
-      case AccessorKind::Address:
-      case AccessorKind::MutableAddress:
-        if (FD->getAddressorKind() == AddressorKind::NotAddressor) {
-          Out << "addressor does not have an addressor kind\n";
-          abort();
-        }
-        break;
-      }
-
       verifyCheckedBase(FD);
     }