Merge pull request #13635 from davezarzycki/basic_nfc_inline_bitfield_cleanup

Author: swift-ci

include/swift/AST/Decl.h

@@ -236,6 +236,9 @@ bool conflicting(const OverloadSignature& sig1, const OverloadSignature& sig2);
 
 /// Decl - Base class for all declarations in Swift.
 class alignas(1 << DeclAlignInBits) Decl {
+protected:
+  union { uint64_t OpaqueBits;
+
   SWIFT_INLINE_BITFIELD_BASE(Decl, bitmax(NumDeclKindBits,8)+1+1+1+1+1+1+1,
     Kind : bitmax(NumDeclKindBits,8),
 
@@ -587,34 +590,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     NumberOfVTableEntries : 2
   );
 
-protected:
-  union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITS(Decl);
-    SWIFT_INLINE_BITS(PatternBindingDecl);
-    SWIFT_INLINE_BITS(EnumCaseDecl);
-    SWIFT_INLINE_BITS(ValueDecl);
-    SWIFT_INLINE_BITS(AbstractStorageDecl);
-    SWIFT_INLINE_BITS(AbstractFunctionDecl);
-    SWIFT_INLINE_BITS(VarDecl);
-    SWIFT_INLINE_BITS(ParamDecl);
-    SWIFT_INLINE_BITS(EnumElementDecl);
-    SWIFT_INLINE_BITS(FuncDecl);
-    SWIFT_INLINE_BITS(ConstructorDecl);
-    SWIFT_INLINE_BITS(TypeDecl);
-    SWIFT_INLINE_BITS(GenericTypeParamDecl);
-    SWIFT_INLINE_BITS(TypeAliasDecl);
-    SWIFT_INLINE_BITS(NominalTypeDecl);
-    SWIFT_INLINE_BITS(ProtocolDecl);
-    SWIFT_INLINE_BITS(ClassDecl);
-    SWIFT_INLINE_BITS(StructDecl);
-    SWIFT_INLINE_BITS(EnumDecl);
-    SWIFT_INLINE_BITS(AssociatedTypeDecl);
-    SWIFT_INLINE_BITS(PrecedenceGroupDecl);
-    SWIFT_INLINE_BITS(ImportDecl);
-    SWIFT_INLINE_BITS(ExtensionDecl);
-    SWIFT_INLINE_BITS(IfConfigDecl);
-    SWIFT_INLINE_BITS(MissingMemberDecl);
   } Bits;
 
   // Storage for the declaration attributes.

include/swift/AST/Expr.h

@@ -130,6 +130,9 @@ class alignas(8) Expr {
   Expr(const Expr&) = delete;
   void operator=(const Expr&) = delete;
 
+protected:
+  union { uint64_t OpaqueBits;
+
   SWIFT_INLINE_BITFIELD_BASE(Expr, bitmax(NumExprKindBits,8)+2+1,
     /// The subclass of Expr that this is.
     Kind : bitmax(NumExprKindBits,8),
@@ -363,41 +366,6 @@ class alignas(8) Expr {
     NumElements : 32
   );
 
-protected:
-  union {
-    SWIFT_INLINE_BITS(Expr);
-    SWIFT_INLINE_BITS(NumberLiteralExpr);
-    SWIFT_INLINE_BITS(StringLiteralExpr);
-    SWIFT_INLINE_BITS(DeclRefExpr);
-    SWIFT_INLINE_BITS(UnresolvedDeclRefExpr);
-    SWIFT_INLINE_BITS(TupleExpr);
-    SWIFT_INLINE_BITS(TupleElementExpr);
-    SWIFT_INLINE_BITS(MemberRefExpr);
-    SWIFT_INLINE_BITS(UnresolvedDotExpr);
-    SWIFT_INLINE_BITS(SubscriptExpr);
-    SWIFT_INLINE_BITS(DynamicSubscriptExpr);
-    SWIFT_INLINE_BITS(UnresolvedMemberExpr);
-    SWIFT_INLINE_BITS(OverloadSetRefExpr);
-    SWIFT_INLINE_BITS(BooleanLiteralExpr);
-    SWIFT_INLINE_BITS(MagicIdentifierLiteralExpr);
-    SWIFT_INLINE_BITS(ObjectLiteralExpr);
-    SWIFT_INLINE_BITS(AbstractClosureExpr);
-    SWIFT_INLINE_BITS(ClosureExpr);
-    SWIFT_INLINE_BITS(BindOptionalExpr);
-    SWIFT_INLINE_BITS(ApplyExpr);
-    SWIFT_INLINE_BITS(CallExpr);
-    SWIFT_INLINE_BITS(CheckedCastExpr);
-    SWIFT_INLINE_BITS(TupleShuffleExpr);
-    SWIFT_INLINE_BITS(InOutToPointerExpr);
-    SWIFT_INLINE_BITS(ArrayToPointerExpr);
-    SWIFT_INLINE_BITS(ObjCSelectorExpr);
-    SWIFT_INLINE_BITS(KeyPathExpr);
-    SWIFT_INLINE_BITS(ParenExpr);
-    SWIFT_INLINE_BITS(SequenceExpr);
-    SWIFT_INLINE_BITS(CollectionExpr);
-    SWIFT_INLINE_BITS(ErasureExpr);
-    SWIFT_INLINE_BITS(UnresolvedSpecializeExpr);
-    SWIFT_INLINE_BITS(CaptureListExpr);
   } Bits;
 
 private:
@@ -410,6 +378,7 @@ class alignas(8) Expr {
 
 protected:
   Expr(ExprKind Kind, bool Implicit, Type Ty = Type()) : Ty(Ty) {
+    Bits.OpaqueBits = 0;
     Bits.Expr.Kind = unsigned(Kind);
     Bits.Expr.Implicit = Implicit;
     Bits.Expr.LValueAccessKind = 0;

include/swift/AST/Pattern.h

@@ -49,6 +49,9 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, PatternKind kind);
 
 /// Pattern - Base class for all patterns in Swift.
 class alignas(8) Pattern {
+protected:
+  union { uint64_t OpaqueBits;
+
   SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1,
     Kind : bitmax(NumPatternKindBits,8),
     isImplicit : 1,
@@ -64,12 +67,6 @@ class alignas(8) Pattern {
     IsPropagatedType : 1
   );
 
-protected:
-  union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITS(Pattern);
-    SWIFT_INLINE_BITS(TuplePattern);
-    SWIFT_INLINE_BITS(TypedPattern);
   } Bits;
 
   Pattern(PatternKind kind) {

include/swift/AST/Stmt.h

@@ -51,6 +51,9 @@ class alignas(8) Stmt {
   Stmt(const Stmt&) = delete;
   Stmt& operator=(const Stmt&) = delete;
 
+protected:
+  union { uint64_t OpaqueBits;
+
   SWIFT_INLINE_BITFIELD_BASE(Stmt, bitmax(NumStmtKindBits,8) + 1,
     /// Kind - The subclass of Stmt that this is.
     Kind : bitmax(NumStmtKindBits,8),
@@ -81,14 +84,6 @@ class alignas(8) Stmt {
     CaseCount : 32
   );
 
-protected:
-  union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITS(Stmt);
-    SWIFT_INLINE_BITS(BraceStmt);
-    SWIFT_INLINE_BITS(DoCatchStmt);
-    SWIFT_INLINE_BITS(CaseStmt);
-    SWIFT_INLINE_BITS(SwitchStmt);
   } Bits;
 
   /// Return the given value for the 'implicit' flag if present, or if None,

include/swift/AST/TypeRepr.h

@@ -49,6 +49,9 @@ class alignas(8) TypeRepr {
   TypeRepr(const TypeRepr&) = delete;
   void operator=(const TypeRepr&) = delete;
 
+protected:
+  union { uint64_t OpaqueBits;
+
   SWIFT_INLINE_BITFIELD_BASE(TypeRepr, bitmax(NumTypeReprKindBits,8)+1+1,
     /// The subclass of TypeRepr that this is.
     Kind : bitmax(NumTypeReprKindBits,8),
@@ -71,11 +74,6 @@ class alignas(8) TypeRepr {
     NumElements : 16
   );
 
-protected:
-  union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITS(TypeRepr);
-    SWIFT_INLINE_BITS(TupleTypeRepr);
   } Bits;
 
   TypeRepr(TypeReprKind K) {

include/swift/AST/Types.h

@@ -259,14 +259,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// form of a non-canonical type is requested.
   llvm::PointerUnion<TypeBase *, const ASTContext *> CanonicalType;
 
-  SWIFT_INLINE_BITFIELD_BASE(TypeBase, bitmax(NumTypeKindBits,8) +
-                             RecursiveTypeProperties::BitWidth,
-    /// Kind - The discriminator that indicates what subclass of type this is.
-    Kind : bitmax(NumTypeKindBits,8),
-
-    Properties : RecursiveTypeProperties::BitWidth
-  );
-
   /// Returns true if the given type is a sugared type.
   ///
   /// Only intended for use in compile-time assertions.
@@ -277,6 +269,18 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   }
 
 protected:
+  enum { NumAFTExtInfoBits = 7 };
+  enum { NumSILExtInfoBits = 6 };
+  union { uint64_t OpaqueBits;
+
+  SWIFT_INLINE_BITFIELD_BASE(TypeBase, bitmax(NumTypeKindBits,8) +
+                             RecursiveTypeProperties::BitWidth,
+    /// Kind - The discriminator that indicates what subclass of type this is.
+    Kind : bitmax(NumTypeKindBits,8),
+
+    Properties : RecursiveTypeProperties::BitWidth
+  );
+
   SWIFT_INLINE_BITFIELD(ErrorType, TypeBase, 1,
     /// Whether there is an original type.
     HasOriginalType : 1
@@ -288,7 +292,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     Flags : NumFlagBits
   );
 
-  enum { NumAFTExtInfoBits = 7 };
   SWIFT_INLINE_BITFIELD_FULL(AnyFunctionType, TypeBase, NumAFTExtInfoBits+16,
     /// Extra information which affects how the function is called, like
     /// regparm and the calling convention.
@@ -318,7 +321,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     GraphIndex : 29
   );
 
-  enum { NumSILExtInfoBits = 6 };
   SWIFT_INLINE_BITFIELD(SILFunctionType, TypeBase, NumSILExtInfoBits+3+1+2,
     ExtInfo : NumSILExtInfoBits,
     CalleeConvention : 3,
@@ -367,20 +369,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     GenericArgCount : 32
   );
 
-  union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITS(TypeBase);
-    SWIFT_INLINE_BITS(ErrorType);
-    SWIFT_INLINE_BITS(ParenType);
-    SWIFT_INLINE_BITS(AnyFunctionType);
-    SWIFT_INLINE_BITS(TypeVariableType);
-    SWIFT_INLINE_BITS(ArchetypeType);
-    SWIFT_INLINE_BITS(SILFunctionType);
-    SWIFT_INLINE_BITS(SILBoxType);
-    SWIFT_INLINE_BITS(AnyMetatypeType);
-    SWIFT_INLINE_BITS(ProtocolCompositionType);
-    SWIFT_INLINE_BITS(TupleType);
-    SWIFT_INLINE_BITS(BoundGenericType);
   } Bits;
 
 protected:

include/swift/Basic/InlineBitfield.h

@@ -38,21 +38,21 @@ namespace swift {
   class T##Bitfield { \
     friend class T; \
     uint64_t __VA_ARGS__; \
-    uint64_t : 64 - (C); /* Pad and error if C > 64 */ \
-  }; \
+  } T; \
   LLVM_PACKED_END \
-  enum { Num##T##Bits = (C) }
+  enum { Num##T##Bits = (C) }; \
+  static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
 /// Define an bitfield for type 'T' with parent class 'U' and 'C' bits used.
 #define SWIFT_INLINE_BITFIELD(T, U, C, ...) \
   LLVM_PACKED_START \
   class T##Bitfield { \
     friend class T; \
     uint64_t : Num##U##Bits, __VA_ARGS__; \
-    uint64_t : 64 - (Num##U##Bits + (C)); /* Pad and error if C > 64 */ \
-  }; \
+  } T; \
   LLVM_PACKED_END \
-  enum { Num##T##Bits = Num##U##Bits + (C) }
+  enum { Num##T##Bits = Num##U##Bits + (C) }; \
+  static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
 /// Define a full bitfield for type 'T' that uses all of the remaining bits in
 /// the inline bitfield.
@@ -72,16 +72,14 @@ namespace swift {
     friend class T; \
     enum { NumPadBits = 64 - (Num##U##Bits + (C)) }; \
     uint64_t : Num##U##Bits, __VA_ARGS__; \
-  }; \
+  } T; \
   LLVM_PACKED_END \
   static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
 /// Define an empty bitfield for type 'T'.
 #define SWIFT_INLINE_BITFIELD_EMPTY(T, U) \
   enum { Num##T##Bits = Num##U##Bits }
 
-#define SWIFT_INLINE_BITS(T) T##Bitfield T
-
 // XXX/HACK: templated max() doesn't seem to work in a bitfield size context.
 constexpr unsigned bitmax(unsigned a, unsigned b) {
   return a > b ? a : b;