[Index] Reduce size of SymbolInfo struct.

[sammccall]

Summary

This is currently 16 bytes, the patch reduces it to 4.
(Building with clang on linux x84, I guess others are similar)

The only subfield that might need a bigger type is SymbolPropertySet,
I've moved it to the end of the struct so if it grows, SymbolInfo will
only be 8 bytes.

With a full index of namespace-scope symbols from the LLVM project (200k)
loaded into clangd, this saves ~2MB of RAM.

[akyrtzi]

Nice one! One minor change I'd suggest is to change SymbolProperty to enum class SymbolProperty : SymbolPropertySet, so that if it needs to increase we only change the type in one place.

[sammccall]

Avoid repeating uint8_t type for SymbolProperty/SymbolPropertySet.

[akyrtzi]

LGTM!

include/clang/Index/IndexSymbol.h

enum class SymbolKind : uint8_t {
   Constructor,
   Destructor,
   ConversionFunction,
 
   Parameter,
   Using,
 };
 
-enum class SymbolLanguage {
+enum class SymbolLanguage : uint8_t {
   C,
   ObjC,
   CXX,
   Swift,
 };
 
 /// Language specific sub-kinds.
-enum class SymbolSubKind {
+enum class SymbolSubKind : uint8_t {
   None,
   CXXCopyConstructor,
   CXXMoveConstructor,
   AccessorGetter,
   AccessorSetter,
   UsingTypename,
   UsingValue,
 };
 
 /// Set of properties that provide additional info about a symbol.
 enum class SymbolProperty : uint8_t {
   Generic                       = 1 << 0,
   TemplatePartialSpecialization = 1 << 1,
   TemplateSpecialization        = 1 << 2,
   UnitTest                      = 1 << 3,
   IBAnnotated                   = 1 << 4,
   IBOutletCollection            = 1 << 5,
   GKInspectable                 = 1 << 6,
   Local                         = 1 << 7,
 };
 static const unsigned SymbolPropertyBitNum = 8;
-typedef unsigned SymbolPropertySet;
+typedef uint8_t SymbolPropertySet;
 
 /// Set of roles that are attributed to symbol occurrences.
 enum class SymbolRole : uint32_t {
   Declaration = 1 << 0,
   Definition  = 1 << 1,
   Reference   = 1 << 2,
   Read        = 1 << 3,
   Write       = 1 << 4,
struct SymbolRelation {
 
   SymbolRelation(SymbolRoleSet Roles, const Decl *Sym)
     : Roles(Roles), RelatedSymbol(Sym) {}
 };
 
 struct SymbolInfo {
   SymbolKind Kind;
   SymbolSubKind SubKind;
-  SymbolPropertySet Properties;
   SymbolLanguage Lang;
+  SymbolPropertySet Properties;
 };
 
 SymbolInfo getSymbolInfo(const Decl *D);
 
 bool isFunctionLocalSymbol(const Decl *D);
 
 void applyForEachSymbolRole(SymbolRoleSet Roles,
                             llvm::function_ref<void(SymbolRole)> Fn);

lib/Index/IndexSymbol.cpp

if (!D->getReturnType()->isVoidType())
     return false;
   if (!D->getSelector().getNameForSlot(0).startswith("test"))
     return false;
   return isUnitTestCase(D->getClassInterface());
 }
 
 static void checkForIBOutlets(const Decl *D, SymbolPropertySet &PropSet) {
   if (D->hasAttr<IBOutletAttr>()) {
-    PropSet |= (unsigned)SymbolProperty::IBAnnotated;
+    PropSet |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
   } else if (D->hasAttr<IBOutletCollectionAttr>()) {
-    PropSet |= (unsigned)SymbolProperty::IBAnnotated;
-    PropSet |= (unsigned)SymbolProperty::IBOutletCollection;
+    PropSet |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
+    PropSet |= (SymbolPropertySet)SymbolProperty::IBOutletCollection;
   }
 }
 
 bool index::isFunctionLocalSymbol(const Decl *D) {
   assert(D);
 
   if (isa<ParmVarDecl>(D))
     return true;
SymbolInfo index::getSymbolInfo(const Decl *D) {
   assert(D);
   SymbolInfo Info;
   Info.Kind = SymbolKind::Unknown;
   Info.SubKind = SymbolSubKind::None;
   Info.Properties = SymbolPropertySet();
   Info.Lang = SymbolLanguage::C;
 
   if (isFunctionLocalSymbol(D)) {
-    Info.Properties |= (unsigned)SymbolProperty::Local;
+    Info.Properties |= (SymbolPropertySet)SymbolProperty::Local;
   }
 
   if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
     switch (TD->getTagKind()) {
     case TTK_Struct:
       Info.Kind = SymbolKind::Struct; break;
     case TTK_Union:
       Info.Kind = SymbolKind::Union; break;
     case TTK_Class:
       Info.Kind = SymbolKind::Class;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case TTK_Interface:
       Info.Kind = SymbolKind::Protocol;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case TTK_Enum:
       Info.Kind = SymbolKind::Enum; break;
     }
 
     if (const CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(D)) {
       if (!CXXRec->isCLike()) {
         Info.Lang = SymbolLanguage::CXX;
         if (CXXRec->getDescribedClassTemplate()) {
-          Info.Properties |= (unsigned)SymbolProperty::Generic;
+          Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
         }
       }
     }
 
     if (isa<ClassTemplatePartialSpecializationDecl>(D)) {
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
-      Info.Properties |= (unsigned)SymbolProperty::TemplatePartialSpecialization;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      Info.Properties |=
+          (SymbolPropertySet)SymbolProperty::TemplatePartialSpecialization;
     } else if (isa<ClassTemplateSpecializationDecl>(D)) {
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
-      Info.Properties |= (unsigned)SymbolProperty::TemplateSpecialization;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      Info.Properties |=
+          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
     }
 
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
     Info.Kind = SymbolKind::Variable;
     if (isa<ParmVarDecl>(D)) {
       Info.Kind = SymbolKind::Parameter;
     } else if (isa<CXXRecordDecl>(D->getDeclContext())) {
       Info.Kind = SymbolKind::StaticProperty;
       Info.Lang = SymbolLanguage::CXX;
     }
 
     if (isa<VarTemplatePartialSpecializationDecl>(D)) {
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
-      Info.Properties |= (unsigned)SymbolProperty::TemplatePartialSpecialization;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      Info.Properties |=
+          (SymbolPropertySet)SymbolProperty::TemplatePartialSpecialization;
     } else if (isa<VarTemplateSpecializationDecl>(D)) {
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
-      Info.Properties |= (unsigned)SymbolProperty::TemplateSpecialization;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      Info.Properties |=
+          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
     } else if (VD->getDescribedVarTemplate()) {
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
     }
 
   } else {
     switch (D->getKind()) {
     case Decl::Import:
       Info.Kind = SymbolKind::Module;
       break;
     case Decl::Typedef:
if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
     case Decl::ObjCInterface:
     case Decl::ObjCImplementation: {
       Info.Kind = SymbolKind::Class;
       Info.Lang = SymbolLanguage::ObjC;
       const ObjCInterfaceDecl *ClsD = dyn_cast<ObjCInterfaceDecl>(D);
       if (!ClsD)
         ClsD = cast<ObjCImplementationDecl>(D)->getClassInterface();
       if (isUnitTestCase(ClsD))
-        Info.Properties |= (unsigned)SymbolProperty::UnitTest;
+        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
       break;
     }
     case Decl::ObjCProtocol:
       Info.Kind = SymbolKind::Protocol;
       Info.Lang = SymbolLanguage::ObjC;
       break;
     case Decl::ObjCCategory:
     case Decl::ObjCCategoryImpl: {
       Info.Kind = SymbolKind::Extension;
       Info.Lang = SymbolLanguage::ObjC;
       const ObjCInterfaceDecl *ClsD = nullptr;
       if (auto *CatD = dyn_cast<ObjCCategoryDecl>(D))
         ClsD = CatD->getClassInterface();
       else
         ClsD = cast<ObjCCategoryImplDecl>(D)->getClassInterface();
       if (isUnitTestCase(ClsD))
-        Info.Properties |= (unsigned)SymbolProperty::UnitTest;
+        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
       break;
     }
     case Decl::ObjCMethod: {
       const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D);
       Info.Kind = MD->isInstanceMethod() ? SymbolKind::InstanceMethod : SymbolKind::ClassMethod;
       if (MD->isPropertyAccessor()) {
         if (MD->param_size())
           Info.SubKind = SymbolSubKind::AccessorSetter;
         else
           Info.SubKind = SymbolSubKind::AccessorGetter;
       }
       Info.Lang = SymbolLanguage::ObjC;
       if (isUnitTest(MD))
-        Info.Properties |= (unsigned)SymbolProperty::UnitTest;
+        Info.Properties |= (SymbolPropertySet)SymbolProperty::UnitTest;
       if (D->hasAttr<IBActionAttr>())
-        Info.Properties |= (unsigned)SymbolProperty::IBAnnotated;
+        Info.Properties |= (SymbolPropertySet)SymbolProperty::IBAnnotated;
       break;
     }
     case Decl::ObjCProperty:
       Info.Kind = SymbolKind::InstanceProperty;
       Info.Lang = SymbolLanguage::ObjC;
       checkForIBOutlets(D, Info.Properties);
       if (auto *Annot = D->getAttr<AnnotateAttr>()) {
         if (Annot->getAnnotation() == "gk_inspectable")
-          Info.Properties |= (unsigned)SymbolProperty::GKInspectable;
+          Info.Properties |= (SymbolPropertySet)SymbolProperty::GKInspectable;
       }
       break;
     case Decl::ObjCIvar:
       Info.Kind = SymbolKind::Field;
       Info.Lang = SymbolLanguage::ObjC;
       checkForIBOutlets(D, Info.Properties);
       break;
     case Decl::Namespace:
case Decl::CXXMethod: {
         Info.Kind = SymbolKind::StaticMethod;
       else
         Info.Kind = SymbolKind::InstanceMethod;
       Info.Lang = SymbolLanguage::CXX;
       break;
     }
     case Decl::ClassTemplate:
       Info.Kind = SymbolKind::Class;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case Decl::FunctionTemplate:
       Info.Kind = SymbolKind::Function;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       Info.Lang = SymbolLanguage::CXX;
       if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(
                            cast<FunctionTemplateDecl>(D)->getTemplatedDecl())) {
         if (isa<CXXConstructorDecl>(MD))
           Info.Kind = SymbolKind::Constructor;
         else if (isa<CXXDestructorDecl>(MD))
           Info.Kind = SymbolKind::Destructor;
         else if (isa<CXXConversionDecl>(MD))
           Info.Kind = SymbolKind::ConversionFunction;
         else {
           if (MD->isStatic())
             Info.Kind = SymbolKind::StaticMethod;
           else
             Info.Kind = SymbolKind::InstanceMethod;
         }
       }
       break;
     case Decl::TypeAliasTemplate:
       Info.Kind = SymbolKind::TypeAlias;
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       break;
     case Decl::TypeAlias:
       Info.Kind = SymbolKind::TypeAlias;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case Decl::UnresolvedUsingTypename:
       Info.Kind = SymbolKind::Using;
       Info.SubKind = SymbolSubKind::UsingTypename;
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       break;
     case Decl::UnresolvedUsingValue:
       Info.Kind = SymbolKind::Using;
       Info.SubKind = SymbolSubKind::UsingValue;
       Info.Lang = SymbolLanguage::CXX;
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       break;
     case Decl::Binding:
       Info.Kind = SymbolKind::Variable;
       Info.Lang = SymbolLanguage::CXX;
       break;
     default:
       break;
     }
   }
 
   if (Info.Kind == SymbolKind::Unknown)
     return Info;
 
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->getTemplatedKind() ==
           FunctionDecl::TK_FunctionTemplateSpecialization) {
-      Info.Properties |= (unsigned)SymbolProperty::Generic;
-      Info.Properties |= (unsigned)SymbolProperty::TemplateSpecialization;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      Info.Properties |=
+          (SymbolPropertySet)SymbolProperty::TemplateSpecialization;
     }
   }
 
-  if (Info.Properties & (unsigned)SymbolProperty::Generic)
+  if (Info.Properties & (SymbolPropertySet)SymbolProperty::Generic)
     Info.Lang = SymbolLanguage::CXX;
 
   if (auto *attr = D->getExternalSourceSymbolAttr()) {
     if (attr->getLanguage() == "Swift")
       Info.Lang = SymbolLanguage::Swift;
   }
 
   return Info;
StringRef index::getSymbolLanguageString(SymbolLanguage K) {
   case SymbolLanguage::CXX: return "C++";
   case SymbolLanguage::Swift: return "Swift";
   }
   llvm_unreachable("invalid symbol language kind");
 }
 
 void index::applyForEachSymbolProperty(SymbolPropertySet Props,
                                   llvm::function_ref<void(SymbolProperty)> Fn) {
-#define APPLY_FOR_PROPERTY(K) \
-  if (Props & (unsigned)SymbolProperty::K) \
-    Fn(SymbolProperty::K)
+#define APPLY_FOR_PROPERTY(K)                                                  \
+  if (Props & (SymbolPropertySet)SymbolProperty::K)                            \
 
   APPLY_FOR_PROPERTY(Generic);
   APPLY_FOR_PROPERTY(TemplatePartialSpecialization);
   APPLY_FOR_PROPERTY(TemplateSpecialization);
   APPLY_FOR_PROPERTY(UnitTest);
   APPLY_FOR_PROPERTY(IBAnnotated);
   APPLY_FOR_PROPERTY(IBOutletCollection);
   APPLY_FOR_PROPERTY(GKInspectable);

tools/libclang/CXIndexDataConsumer.cpp

static CXIdxEntityKind getEntityKindFromSymbolKind(SymbolKind K, SymbolLanguage Lang) {
   case SymbolKind::ConversionFunction: return CXIdxEntity_CXXConversionFunction;
   case SymbolKind::Parameter: return CXIdxEntity_Variable;
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 static CXIdxEntityCXXTemplateKind
 getEntityKindFromSymbolProperties(SymbolPropertySet K) {
-  if (K & (unsigned)SymbolProperty::TemplatePartialSpecialization)
+  if (K & (SymbolPropertySet)SymbolProperty::TemplatePartialSpecialization)
     return CXIdxEntity_TemplatePartialSpecialization;
-  if (K & (unsigned)SymbolProperty::TemplateSpecialization)
+  if (K & (SymbolPropertySet)SymbolProperty::TemplateSpecialization)
     return CXIdxEntity_TemplateSpecialization;
-  if (K & (unsigned)SymbolProperty::Generic)
+  if (K & (SymbolPropertySet)SymbolProperty::Generic)
     return CXIdxEntity_Template;
   return CXIdxEntity_NonTemplate;
 }
 
 static CXIdxEntityLanguage getEntityLangFromSymbolLang(SymbolLanguage L) {
   switch (L) {
   case SymbolLanguage::C: return CXIdxEntityLang_C;
   case SymbolLanguage::ObjC: return CXIdxEntityLang_ObjC;
   case SymbolLanguage::CXX: return CXIdxEntityLang_CXX;
   case SymbolLanguage::Swift: return CXIdxEntityLang_Swift;
   }
   llvm_unreachable("invalid symbol language");
 }