[Reflection] NFC: Adopt reference storage type meta-programming macros

Author: davezarzycki

include/swift/Reflection/TypeLowering.h

@@ -97,9 +97,8 @@ enum class ReferenceCounting : unsigned {
 
 enum class ReferenceKind : unsigned {
   Strong,
-  Unowned,
-  Weak,
-  Unmanaged
+#define REF_STORAGE(Name, ...) Name,
+#include "swift/AST/ReferenceStorage.def"
 };
 
 enum class TypeInfoKind : unsigned {

include/swift/Reflection/TypeRef.h

@@ -667,63 +667,33 @@ class ReferenceStorageTypeRef : public TypeRef {
   }
 
   static bool classof(const TypeRef *TR) {
-    auto Kind = TR->getKind();
-    return (Kind == TypeRefKind::UnownedStorage ||
-            Kind == TypeRefKind::WeakStorage ||
-            Kind == TypeRefKind::UnmanagedStorage);
-  }
-};
-
-class UnownedStorageTypeRef final : public ReferenceStorageTypeRef {
-  using ReferenceStorageTypeRef::Profile;
-public:
-  UnownedStorageTypeRef(const TypeRef *Type)
-    : ReferenceStorageTypeRef(TypeRefKind::UnownedStorage, Type) {}
-
-  template <typename Allocator>
-  static const UnownedStorageTypeRef *create(Allocator &A,
-                                             const TypeRef *Type) {
-    FIND_OR_CREATE_TYPEREF(A, UnownedStorageTypeRef, Type);
-  }
-
-  static bool classof(const TypeRef *TR) {
-    return TR->getKind() == TypeRefKind::UnownedStorage;
-  }
-};
-
-class WeakStorageTypeRef final : public ReferenceStorageTypeRef {
-  using ReferenceStorageTypeRef::Profile;
-public:
-  WeakStorageTypeRef(const TypeRef *Type)
-    : ReferenceStorageTypeRef(TypeRefKind::WeakStorage, Type) {}
-
-  template <typename Allocator>
-  static const WeakStorageTypeRef *create(Allocator &A,
-                                          const TypeRef *Type) {
-    FIND_OR_CREATE_TYPEREF(A, WeakStorageTypeRef, Type);
-  }
-
-  static bool classof(const TypeRef *TR) {
-    return TR->getKind() == TypeRefKind::WeakStorage;
+    switch (TR->getKind()) {
+#define REF_STORAGE(Name, ...) \
+    case TypeRefKind::Name##Storage:
+#include "swift/AST/ReferenceStorage.def"
+      return true;
+    default:
+      return false;
+    }
   }
 };
 
-class UnmanagedStorageTypeRef final : public ReferenceStorageTypeRef {
-  using ReferenceStorageTypeRef::Profile;
-public:
-  UnmanagedStorageTypeRef(const TypeRef *Type)
-    : ReferenceStorageTypeRef(TypeRefKind::UnmanagedStorage, Type) {}
-
-  template <typename Allocator>
-  static const UnmanagedStorageTypeRef *create(Allocator &A,
-                                               const TypeRef *Type) {
-    FIND_OR_CREATE_TYPEREF(A, UnmanagedStorageTypeRef, Type);
-  }
-
-  static bool classof(const TypeRef *TR) {
-    return TR->getKind() == TypeRefKind::UnmanagedStorage;
-  }
-};
+#define REF_STORAGE(Name, ...) \
+  class Name##StorageTypeRef final : public ReferenceStorageTypeRef { \
+    using ReferenceStorageTypeRef::Profile; \
+  public: \
+    Name##StorageTypeRef(const TypeRef *Type) \
+      : ReferenceStorageTypeRef(TypeRefKind::Name##Storage, Type) {} \
+    template <typename Allocator> \
+    static const Name##StorageTypeRef *create(Allocator &A, \
+                                              const TypeRef *Type) { \
+      FIND_OR_CREATE_TYPEREF(A, Name##StorageTypeRef, Type); \
+    } \
+    static bool classof(const TypeRef *TR) { \
+      return TR->getKind() == TypeRefKind::Name##Storage; \
+    } \
+  };
+#include "swift/AST/ReferenceStorage.def"
 
 class SILBoxTypeRef final : public TypeRef {
   const TypeRef *BoxedType;

include/swift/Reflection/TypeRefBuilder.h

@@ -296,18 +296,11 @@ class TypeRefBuilder {
     return DependentMemberTypeRef::create(*this, member, base, *protocol);
   }
 
-  const UnownedStorageTypeRef *createUnownedStorageType(const TypeRef *base) {
-    return UnownedStorageTypeRef::create(*this, base);
-  }
-
-  const UnmanagedStorageTypeRef *
-  createUnmanagedStorageType(const TypeRef *base) {
-    return UnmanagedStorageTypeRef::create(*this, base);
-  }
-
-  const WeakStorageTypeRef *createWeakStorageType(const TypeRef *base) {
-    return WeakStorageTypeRef::create(*this, base);
+#define REF_STORAGE(Name, ...) \
+  const Name##StorageTypeRef *create##Name##StorageType(const TypeRef *base) { \
+    return Name##StorageTypeRef::create(*this, base); \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   const SILBoxTypeRef *createSILBoxType(const TypeRef *base) {
     return SILBoxTypeRef::create(*this, base);

include/swift/Reflection/TypeRefs.def

@@ -29,9 +29,9 @@ TYPEREF(DependentMember, TypeRef)
 TYPEREF(ForeignClass, TypeRef)
 TYPEREF(ObjCClass, TypeRef)
 TYPEREF(Opaque, TypeRef)
-TYPEREF(UnownedStorage, TypeRef)
-TYPEREF(UnmanagedStorage, TypeRef)
-TYPEREF(WeakStorage, TypeRef)
+#define REF_STORAGE(Name, ...) \
+  TYPEREF(Name##Storage, TypeRef)
+#include "swift/AST/ReferenceStorage.def"
 TYPEREF(SILBox, TypeRef)
 
 #undef TYPEREF

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -108,9 +108,9 @@ typedef enum swift_layout_kind {
 
   // References to other objects in the heap.
   SWIFT_STRONG_REFERENCE,
-  SWIFT_UNOWNED_REFERENCE,
-  SWIFT_WEAK_REFERENCE,
-  SWIFT_UNMANAGED_REFERENCE,
+#define REF_STORAGE(Name, name, NAME) \
+  SWIFT_##NAME##_REFERENCE,
+#include "swift/AST/ReferenceStorage.def"
 
   // Layouts of heap objects. These are only ever returned from
   // swift_reflection_infoFor{Instance,Metadata}(), and not

lib/RemoteAST/RemoteAST.cpp

@@ -412,23 +412,13 @@ class RemoteASTTypeBuilder {
     return Type();
   }
 
-  Type createUnownedStorageType(Type base) {
-    if (!base->allowsOwnership())
-      return Type();
-    return UnownedStorageType::get(base, Ctx);
-  }
-
-  Type createUnmanagedStorageType(Type base) {
-    if (!base->allowsOwnership())
-      return Type();
-    return UnmanagedStorageType::get(base, Ctx);
-  }
-
-  Type createWeakStorageType(Type base) {
-    if (!base->allowsOwnership())
-      return Type();
-    return WeakStorageType::get(base, Ctx);
+#define REF_STORAGE(Name, ...) \
+  Type create##Name##StorageType(Type base) { \
+    if (!base->allowsOwnership()) \
+      return Type(); \
+    return Name##StorageType::get(base, Ctx); \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   Type createSILBoxType(Type base) {
     return SILBoxType::get(base->getCanonicalType());

stdlib/public/Reflection/TypeLowering.cpp

@@ -158,18 +158,10 @@ class PrintTypeInfo {
       printHeader("reference");
       auto &ReferenceTI = cast<ReferenceTypeInfo>(TI);
       switch (ReferenceTI.getReferenceKind()) {
-      case ReferenceKind::Strong:
-        printField("kind", "strong");
-        break;
-      case ReferenceKind::Unowned:
-        printField("kind", "unowned");
-        break;
-      case ReferenceKind::Weak:
-        printField("kind", "weak");
-        break;
-      case ReferenceKind::Unmanaged:
-        printField("kind", "unmanaged");
-        break;
+      case ReferenceKind::Strong: printField("kind", "strong"); break;
+#define REF_STORAGE(Name, name, ...) \
+      case ReferenceKind::Name: printField("kind", #name); break;
+#include "swift/AST/ReferenceStorage.def"
       }
 
       switch (ReferenceTI.getReferenceCounting()) {
@@ -706,19 +698,12 @@ class HasFixedSize
     return true;
   }
 
-  bool
-  visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return true;
-  }
-
-  bool visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return true;
-  }
-
-  bool
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return true;
+#define REF_STORAGE(Name, ...) \
+  bool \
+  visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return true; \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   bool
   visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) {
@@ -840,19 +825,12 @@ class HasSingletonMetatype
     return MetatypeRepresentation::Unknown;
   }
 
-  MetatypeRepresentation
-  visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return MetatypeRepresentation::Unknown;
-  }
-
-  MetatypeRepresentation visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return MetatypeRepresentation::Unknown;
-  }
-
-  MetatypeRepresentation
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return MetatypeRepresentation::Unknown;
+#define REF_STORAGE(Name, ...) \
+  MetatypeRepresentation \
+  visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return MetatypeRepresentation::Unknown; \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   MetatypeRepresentation visitOpaqueTypeRef(const OpaqueTypeRef *O) {
     return MetatypeRepresentation::Unknown;
@@ -1255,19 +1233,12 @@ class LowerType
     return rebuildStorageTypeInfo(TC.getTypeInfo(TR), Kind);
   }
 
-  const TypeInfo *
-  visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return visitAnyStorageTypeRef(US->getType(), ReferenceKind::Unowned);
-  }
-
-  const TypeInfo *visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return visitAnyStorageTypeRef(WS->getType(), ReferenceKind::Weak);
-  }
-
-  const TypeInfo *
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return visitAnyStorageTypeRef(US->getType(), ReferenceKind::Unmanaged);
+#define REF_STORAGE(Name, name, ...) \
+  const TypeInfo * \
+  visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return visitAnyStorageTypeRef(US->getType(), ReferenceKind::Name); \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   const TypeInfo *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return TC.getReferenceTypeInfo(ReferenceKind::Strong,

stdlib/public/Reflection/TypeRef.cpp

@@ -236,23 +236,13 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
     OS << ')';
   }
 
-  void visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    printHeader("unowned_storage");
-    printRec(US->getType());
-    OS << ')';
-  }
-
-  void visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    printHeader("weak_storage");
-    printRec(WS->getType());
-    OS << ')';
-  }
-
-  void visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    printHeader("unmanaged_storage");
-    printRec(US->getType());
-    OS << ')';
+#define REF_STORAGE(Name, name, ...) \
+  void visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    printHeader(#name "_storage"); \
+    printRec(US->getType()); \
+    OS << ')'; \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   void visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     printHeader("sil_box");
@@ -349,17 +339,11 @@ struct TypeRefIsConcrete
     return true;
   }
 
-  bool visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return visit(US->getType());
-  }
-
-  bool visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return visit(WS->getType());
-  }
-
-  bool visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return visit(US->getType());
+#define REF_STORAGE(Name, name, ...) \
+  bool visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return visit(US->getType()); \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   bool visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return visit(SB->getBoxedType());
@@ -525,18 +509,11 @@ class ThickenMetatype
     return OC;
   }
 
-  const TypeRef *visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return US;
-  }
-
-  const TypeRef *visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return WS;
-  }
-
-  const TypeRef *
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return US;
+#define REF_STORAGE(Name, name, ...) \
+  const TypeRef *visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return US; \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   const TypeRef *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return SILBoxTypeRef::create(Builder, visit(SB->getBoxedType()));
@@ -698,18 +675,11 @@ class TypeRefSubstitution
     return OC;
   }
 
-  const TypeRef *visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return UnownedStorageTypeRef::create(Builder, visit(US->getType()));
-  }
-
-  const TypeRef *visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return WeakStorageTypeRef::create(Builder, visit(WS->getType()));
-  }
-
-  const TypeRef *
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return UnmanagedStorageTypeRef::create(Builder, visit(US->getType()));
+#define REF_STORAGE(Name, name, ...) \
+  const TypeRef *visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
+    return Name##StorageTypeRef::create(Builder, visit(US->getType())); \
   }
+#include "swift/AST/ReferenceStorage.def"
 
   const TypeRef *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return SILBoxTypeRef::create(Builder, visit(SB->getBoxedType()));

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -278,14 +278,10 @@ swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {
   case TypeInfoKind::Reference: {
     auto &ReferenceTI = cast<ReferenceTypeInfo>(TI);
     switch (ReferenceTI.getReferenceKind()) {
-    case ReferenceKind::Strong:
-      return SWIFT_STRONG_REFERENCE;
-    case ReferenceKind::Unowned:
-      return SWIFT_UNOWNED_REFERENCE;
-    case ReferenceKind::Weak:
-      return SWIFT_WEAK_REFERENCE;
-    case ReferenceKind::Unmanaged:
-      return SWIFT_UNMANAGED_REFERENCE;
+    case ReferenceKind::Strong: return SWIFT_STRONG_REFERENCE;
+#define REF_STORAGE(Name, name, NAME) \
+    case ReferenceKind::Name: return SWIFT_##NAME##_REFERENCE;
+#include "swift/AST/ReferenceStorage.def"
     }
   }
   }