[clang][extract-api] Add support for true anonymous enums

[dang]

Summary

Anonymous enums without a typedef should have a "(anonymous)" identifier.

[zixuw]

clang/test/ExtractAPI/enum.c

693

nit: normalize

702

So the Name of the record is literally (anonymous)? I think this might create problems (well I guess we always had this problem) that multiple anonymous records of the same kind getting the same Name, and RecordMap is indexed with it...
We should switch the key of RecordMaps to USR instead probably.

729

nit: normalize

[dang]

Address code review feedback:

• Normalize test file URIs
• Key RecordMaps by USR instead of by Name

[dang]

clang/test/ExtractAPI/enum.c

702

Agreed, added this to this patch.

[zixuw]

clang/test/ExtractAPI/enum.c

702

Nice! Thanks Daniel!
Could you please also update the test case to see if it now handles two anonymous records correctly?

[dang]

Add a second anonymous enum to the test case to make sure that distinct symbols
are generated for both of them.

[zixuw]

LGTM

clang/include/clang/ExtractAPI/API.h

 /// \code
 ///   /// This is a documentation comment
 ///       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'  First line.
 ///   ///     with multiple lines.
 ///       ^~~~~~~~~~~~~~~~~~~~~~~'         Second line.
 /// \endcode
 using DocComment = std::vector<RawComment::CommentLine>;
 
-// Classes deriving from APIRecord need to have Name be the first constructor
+// Classes deriving from APIRecord need to have USR be the first constructor
 // argument. This is so that they are compatible with `addTopLevelRecord`
 // defined in API.cpp
 /// The base representation of an API record. Holds common symbol information.
 struct APIRecord {
-  StringRef Name;
   StringRef USR;
+  StringRef Name;
   PresumedLoc Location;
   AvailabilityInfo Availability;
   LinkageInfo Linkage;
 
   /// Documentation comment lines attached to this symbol declaration.
   DocComment Comment;
 
   /// Declaration fragments of this symbol declaration.

 private:
   const RecordKind Kind;
 
 public:
   RecordKind getKind() const { return Kind; }
 
   APIRecord() = delete;
 
-  APIRecord(RecordKind Kind, StringRef Name, StringRef USR,
+  APIRecord(RecordKind Kind, StringRef USR, StringRef Name,
             PresumedLoc Location, const AvailabilityInfo &Availability,
             LinkageInfo Linkage, const DocComment &Comment,
             DeclarationFragments Declaration, DeclarationFragments SubHeading)
-      : Name(Name), USR(USR), Location(Location), Availability(Availability),
+      : USR(USR), Name(Name), Location(Location), Availability(Availability),
         Linkage(Linkage), Comment(Comment), Declaration(Declaration),
         SubHeading(SubHeading), Kind(Kind) {}
 
   // Pure virtual destructor to make APIRecord abstract
   virtual ~APIRecord() = 0;
 };
 
 /// This holds information associated with global functions.
 struct GlobalFunctionRecord : APIRecord {
   FunctionSignature Signature;
 
-  GlobalFunctionRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  GlobalFunctionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                        const AvailabilityInfo &Availability,
                        LinkageInfo Linkage, const DocComment &Comment,
                        DeclarationFragments Declaration,
                        DeclarationFragments SubHeading,
                        FunctionSignature Signature)
-      : APIRecord(RK_GlobalFunction, Name, USR, Loc, Availability, Linkage,
+      : APIRecord(RK_GlobalFunction, USR, Name, Loc, Availability, Linkage,
                   Comment, Declaration, SubHeading),
         Signature(Signature) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_GlobalFunction;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with global functions.
 struct GlobalVariableRecord : APIRecord {
-  GlobalVariableRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  GlobalVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                        const AvailabilityInfo &Availability,
                        LinkageInfo Linkage, const DocComment &Comment,
                        DeclarationFragments Declaration,
                        DeclarationFragments SubHeading)
-      : APIRecord(RK_GlobalVariable, Name, USR, Loc, Availability, Linkage,
+      : APIRecord(RK_GlobalVariable, USR, Name, Loc, Availability, Linkage,
                   Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_GlobalVariable;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with enum constants.
 struct EnumConstantRecord : APIRecord {
-  EnumConstantRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  EnumConstantRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      const AvailabilityInfo &Availability,
                      const DocComment &Comment,
                      DeclarationFragments Declaration,
                      DeclarationFragments SubHeading)
-      : APIRecord(RK_EnumConstant, Name, USR, Loc, Availability,
+      : APIRecord(RK_EnumConstant, USR, Name, Loc, Availability,
                   LinkageInfo::none(), Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_EnumConstant;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with enums.
 struct EnumRecord : APIRecord {
   SmallVector<std::unique_ptr<EnumConstantRecord>> Constants;
 
-  EnumRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  EnumRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
              const AvailabilityInfo &Availability, const DocComment &Comment,
              DeclarationFragments Declaration, DeclarationFragments SubHeading)
-      : APIRecord(RK_Enum, Name, USR, Loc, Availability, LinkageInfo::none(),
+      : APIRecord(RK_Enum, USR, Name, Loc, Availability, LinkageInfo::none(),
                   Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_Enum;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with struct fields.
 struct StructFieldRecord : APIRecord {
-  StructFieldRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  StructFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                     const AvailabilityInfo &Availability,
                     const DocComment &Comment, DeclarationFragments Declaration,
                     DeclarationFragments SubHeading)
-      : APIRecord(RK_StructField, Name, USR, Loc, Availability,
+      : APIRecord(RK_StructField, USR, Name, Loc, Availability,
                   LinkageInfo::none(), Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_StructField;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with structs.
 struct StructRecord : APIRecord {
   SmallVector<std::unique_ptr<StructFieldRecord>> Fields;
 
-  StructRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  StructRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                const AvailabilityInfo &Availability, const DocComment &Comment,
                DeclarationFragments Declaration,
                DeclarationFragments SubHeading)
-      : APIRecord(RK_Struct, Name, USR, Loc, Availability, LinkageInfo::none(),
+      : APIRecord(RK_Struct, USR, Name, Loc, Availability, LinkageInfo::none(),
                   Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_Struct;
   }
 
 private:
   virtual void anchor();
enum AttributeKind : unsigned {
     Dynamic = 1 << 2,
   };
 
   AttributeKind Attributes;
   StringRef GetterName;
   StringRef SetterName;
   bool IsOptional;
 
-  ObjCPropertyRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCPropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      const AvailabilityInfo &Availability,
                      const DocComment &Comment,
                      DeclarationFragments Declaration,
                      DeclarationFragments SubHeading, AttributeKind Attributes,
                      StringRef GetterName, StringRef SetterName,
                      bool IsOptional)
-      : APIRecord(RK_ObjCProperty, Name, USR, Loc, Availability,
+      : APIRecord(RK_ObjCProperty, USR, Name, Loc, Availability,
                   LinkageInfo::none(), Comment, Declaration, SubHeading),
         Attributes(Attributes), GetterName(GetterName), SetterName(SetterName),
         IsOptional(IsOptional) {}
 
   bool isReadOnly() const { return Attributes & ReadOnly; }
   bool isDynamic() const { return Attributes & Dynamic; }
   bool isClassProperty() const { return Attributes & Class; }
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCProperty;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with Objective-C instance variables.
 struct ObjCInstanceVariableRecord : APIRecord {
   using AccessControl = ObjCIvarDecl::AccessControl;
   AccessControl Access;
 
-  ObjCInstanceVariableRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCInstanceVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                              const AvailabilityInfo &Availability,
                              const DocComment &Comment,
                              DeclarationFragments Declaration,
                              DeclarationFragments SubHeading,
                              AccessControl Access)
-      : APIRecord(RK_ObjCIvar, Name, USR, Loc, Availability,
+      : APIRecord(RK_ObjCIvar, USR, Name, Loc, Availability,
                   LinkageInfo::none(), Comment, Declaration, SubHeading),
         Access(Access) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCIvar;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with Objective-C methods.
 struct ObjCMethodRecord : APIRecord {
   FunctionSignature Signature;
   bool IsInstanceMethod;
 
-  ObjCMethodRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                    const AvailabilityInfo &Availability,
                    const DocComment &Comment, DeclarationFragments Declaration,
                    DeclarationFragments SubHeading, FunctionSignature Signature,
                    bool IsInstanceMethod)
-      : APIRecord(RK_ObjCMethod, Name, USR, Loc, Availability,
+      : APIRecord(RK_ObjCMethod, USR, Name, Loc, Availability,
                   LinkageInfo::none(), Comment, Declaration, SubHeading),
         Signature(Signature), IsInstanceMethod(IsInstanceMethod) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCMethod;
   }
 
 private:

 struct ObjCContainerRecord : APIRecord {
   SmallVector<std::unique_ptr<ObjCMethodRecord>> Methods;
   SmallVector<std::unique_ptr<ObjCPropertyRecord>> Properties;
   SmallVector<std::unique_ptr<ObjCInstanceVariableRecord>> Ivars;
   SmallVector<SymbolReference> Protocols;
 
   ObjCContainerRecord() = delete;
 
-  ObjCContainerRecord(RecordKind Kind, StringRef Name, StringRef USR,
+  ObjCContainerRecord(RecordKind Kind, StringRef USR, StringRef Name,
                       PresumedLoc Loc, const AvailabilityInfo &Availability,
                       LinkageInfo Linkage, const DocComment &Comment,
                       DeclarationFragments Declaration,
                       DeclarationFragments SubHeading)
-      : APIRecord(Kind, Name, USR, Loc, Availability, Linkage, Comment,
+      : APIRecord(Kind, USR, Name, Loc, Availability, Linkage, Comment,
                   Declaration, SubHeading) {}
 
   virtual ~ObjCContainerRecord() = 0;
 };
 
 /// This holds information associated with Objective-C categories.
 struct ObjCCategoryRecord : ObjCContainerRecord {
   SymbolReference Interface;
 
-  ObjCCategoryRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCCategoryRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      const AvailabilityInfo &Availability,
                      const DocComment &Comment,
                      DeclarationFragments Declaration,
                      DeclarationFragments SubHeading, SymbolReference Interface)
-      : ObjCContainerRecord(RK_ObjCCategory, Name, USR, Loc, Availability,
+      : ObjCContainerRecord(RK_ObjCCategory, USR, Name, Loc, Availability,
                             LinkageInfo::none(), Comment, Declaration,
                             SubHeading),
         Interface(Interface) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCCategory;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with Objective-C interfaces/classes.
 struct ObjCInterfaceRecord : ObjCContainerRecord {
   SymbolReference SuperClass;
   // ObjCCategoryRecord%s are stored in and owned by APISet.
   SmallVector<ObjCCategoryRecord *> Categories;
 
-  ObjCInterfaceRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCInterfaceRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                       const AvailabilityInfo &Availability, LinkageInfo Linkage,
                       const DocComment &Comment,
                       DeclarationFragments Declaration,
                       DeclarationFragments SubHeading,
                       SymbolReference SuperClass)
-      : ObjCContainerRecord(RK_ObjCInterface, Name, USR, Loc, Availability,
+      : ObjCContainerRecord(RK_ObjCInterface, USR, Name, Loc, Availability,
                             Linkage, Comment, Declaration, SubHeading),
         SuperClass(SuperClass) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCInterface;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with Objective-C protocols.
 struct ObjCProtocolRecord : ObjCContainerRecord {
-  ObjCProtocolRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  ObjCProtocolRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      const AvailabilityInfo &Availability,
                      const DocComment &Comment,
                      DeclarationFragments Declaration,
                      DeclarationFragments SubHeading)
-      : ObjCContainerRecord(RK_ObjCProtocol, Name, USR, Loc, Availability,
+      : ObjCContainerRecord(RK_ObjCProtocol, USR, Name, Loc, Availability,
                             LinkageInfo::none(), Comment, Declaration,
                             SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_ObjCProtocol;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with macro definitions.
 struct MacroDefinitionRecord : APIRecord {
-  MacroDefinitionRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  MacroDefinitionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                         DeclarationFragments Declaration,
                         DeclarationFragments SubHeading)
-      : APIRecord(RK_MacroDefinition, Name, USR, Loc, AvailabilityInfo(),
+      : APIRecord(RK_MacroDefinition, USR, Name, Loc, AvailabilityInfo(),
                   LinkageInfo(), {}, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_MacroDefinition;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with typedefs.
 ///
 /// Note: Typedefs for anonymous enums and structs typically don't get emitted
 /// by the serializers but still get a TypedefRecord. Instead we use the
 /// typedef name as a name for the underlying anonymous struct or enum.
 struct TypedefRecord : APIRecord {
   SymbolReference UnderlyingType;
 
-  TypedefRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+  TypedefRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                 const AvailabilityInfo &Availability, const DocComment &Comment,
                 DeclarationFragments Declaration,
                 DeclarationFragments SubHeading, SymbolReference UnderlyingType)
-      : APIRecord(RK_Typedef, Name, USR, Loc, Availability, LinkageInfo(),
+      : APIRecord(RK_Typedef, USR, Name, Loc, Availability, LinkageInfo(),
                   Comment, Declaration, SubHeading),
         UnderlyingType(UnderlyingType) {}
 
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_Typedef;
   }
 
 private:
public:
   /// to generate the USR for \c D and keep it alive in APISet.
   TypedefRecord *addTypedef(StringRef Name, StringRef USR, PresumedLoc Loc,
                             const AvailabilityInfo &Availability,
                             const DocComment &Comment,
                             DeclarationFragments Declaration,
                             DeclarationFragments SubHeading,
                             SymbolReference UnderlyingType);
 
-  /// A mapping type to store a set of APIRecord%s with the declaration name as
-  /// the key.
+  /// A mapping type to store a set of APIRecord%s with the USR as the key.
   template <typename RecordTy,
             typename =
                 std::enable_if_t<std::is_base_of<APIRecord, RecordTy>::value>>
   using RecordMap = llvm::MapVector<StringRef, std::unique_ptr<RecordTy>>;
 
   /// Get the target triple for the ExtractAPI invocation.
   const llvm::Triple &getTarget() const { return Target; }
 

clang/lib/ExtractAPI/API.cpp

 
 using namespace clang::extractapi;
 using namespace llvm;
 
 namespace {
 
 template <typename RecordTy, typename... CtorArgsTy>
 RecordTy *addTopLevelRecord(APISet::RecordMap<RecordTy> &RecordMap,
-                            StringRef Name, CtorArgsTy &&...CtorArgs) {
-  auto Result = RecordMap.insert({Name, nullptr});
+                            StringRef USR, CtorArgsTy &&...CtorArgs) {
+  auto Result = RecordMap.insert({USR, nullptr});
 
   // Create the record if it does not already exist
   if (Result.second)
     Result.first->second =
-        std::make_unique<RecordTy>(Name, std::forward<CtorArgsTy>(CtorArgs)...);
+        std::make_unique<RecordTy>(USR, std::forward<CtorArgsTy>(CtorArgs)...);
 
   return Result.first->second.get();
 }
 
 } // namespace
 
 GlobalVariableRecord *
 APISet::addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,
                      const AvailabilityInfo &Availability, LinkageInfo Linkage,
                      const DocComment &Comment, DeclarationFragments Fragments,
                      DeclarationFragments SubHeading) {
-  return addTopLevelRecord(GlobalVariables, Name, USR, Loc, Availability,
+  return addTopLevelRecord(GlobalVariables, USR, Name, Loc, Availability,
                            Linkage, Comment, Fragments, SubHeading);
 }
 
 GlobalFunctionRecord *APISet::addGlobalFunction(
     StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, LinkageInfo Linkage,
     const DocComment &Comment, DeclarationFragments Fragments,
     DeclarationFragments SubHeading, FunctionSignature Signature) {
-  return addTopLevelRecord(GlobalFunctions, Name, USR, Loc, Availability,
+  return addTopLevelRecord(GlobalFunctions, USR, Name, Loc, Availability,
                            Linkage, Comment, Fragments, SubHeading, Signature);
 }
 
 EnumConstantRecord *APISet::addEnumConstant(
     EnumRecord *Enum, StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading) {
   auto Record = std::make_unique<EnumConstantRecord>(
-      Name, USR, Loc, Availability, Comment, Declaration, SubHeading);
+      USR, Name, Loc, Availability, Comment, Declaration, SubHeading);
   return Enum->Constants.emplace_back(std::move(Record)).get();
 }
 
 EnumRecord *APISet::addEnum(StringRef Name, StringRef USR, PresumedLoc Loc,
                             const AvailabilityInfo &Availability,
                             const DocComment &Comment,
                             DeclarationFragments Declaration,
                             DeclarationFragments SubHeading) {
-  return addTopLevelRecord(Enums, Name, USR, Loc, Availability, Comment,
+  return addTopLevelRecord(Enums, USR, Name, Loc, Availability, Comment,
                            Declaration, SubHeading);
 }
 
 StructFieldRecord *APISet::addStructField(StructRecord *Struct, StringRef Name,
                                           StringRef USR, PresumedLoc Loc,
                                           const AvailabilityInfo &Availability,
                                           const DocComment &Comment,
                                           DeclarationFragments Declaration,
                                           DeclarationFragments SubHeading) {
   auto Record = std::make_unique<StructFieldRecord>(
-      Name, USR, Loc, Availability, Comment, Declaration, SubHeading);
+      USR, Name, Loc, Availability, Comment, Declaration, SubHeading);
   return Struct->Fields.emplace_back(std::move(Record)).get();
 }
 
 StructRecord *APISet::addStruct(StringRef Name, StringRef USR, PresumedLoc Loc,
                                 const AvailabilityInfo &Availability,
                                 const DocComment &Comment,
                                 DeclarationFragments Declaration,
                                 DeclarationFragments SubHeading) {
-  return addTopLevelRecord(Structs, Name, USR, Loc, Availability, Comment,
+  return addTopLevelRecord(Structs, USR, Name, Loc, Availability, Comment,
                            Declaration, SubHeading);
 }
 
 ObjCCategoryRecord *APISet::addObjCCategory(
     StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading,
     SymbolReference Interface) {
   // Create the category record.
-  auto *Record = addTopLevelRecord(ObjCCategories, Name, USR, Loc, Availability,
+  auto *Record = addTopLevelRecord(ObjCCategories, USR, Name, Loc, Availability,
                                    Comment, Declaration, SubHeading, Interface);
 
   // If this category is extending a known interface, associate it with the
   // ObjCInterfaceRecord.
-  auto It = ObjCInterfaces.find(Interface.Name);
+  auto It = ObjCInterfaces.find(Interface.USR);
   if (It != ObjCInterfaces.end())
     It->second->Categories.push_back(Record);
 
   return Record;
 }
 
 ObjCInterfaceRecord *APISet::addObjCInterface(
     StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, LinkageInfo Linkage,
     const DocComment &Comment, DeclarationFragments Declaration,
     DeclarationFragments SubHeading, SymbolReference SuperClass) {
-  return addTopLevelRecord(ObjCInterfaces, Name, USR, Loc, Availability,
+  return addTopLevelRecord(ObjCInterfaces, USR, Name, Loc, Availability,
                            Linkage, Comment, Declaration, SubHeading,
                            SuperClass);
 }
 
 ObjCMethodRecord *APISet::addObjCMethod(
     ObjCContainerRecord *Container, StringRef Name, StringRef USR,
     PresumedLoc Loc, const AvailabilityInfo &Availability,
     const DocComment &Comment, DeclarationFragments Declaration,
     DeclarationFragments SubHeading, FunctionSignature Signature,
     bool IsInstanceMethod) {
   auto Record = std::make_unique<ObjCMethodRecord>(
-      Name, USR, Loc, Availability, Comment, Declaration, SubHeading, Signature,
+      USR, Name, Loc, Availability, Comment, Declaration, SubHeading, Signature,
       IsInstanceMethod);
   return Container->Methods.emplace_back(std::move(Record)).get();
 }
 
 ObjCPropertyRecord *APISet::addObjCProperty(
     ObjCContainerRecord *Container, StringRef Name, StringRef USR,
     PresumedLoc Loc, const AvailabilityInfo &Availability,
     const DocComment &Comment, DeclarationFragments Declaration,
     DeclarationFragments SubHeading,
     ObjCPropertyRecord::AttributeKind Attributes, StringRef GetterName,
     StringRef SetterName, bool IsOptional) {
   auto Record = std::make_unique<ObjCPropertyRecord>(
-      Name, USR, Loc, Availability, Comment, Declaration, SubHeading,
+      USR, Name, Loc, Availability, Comment, Declaration, SubHeading,
       Attributes, GetterName, SetterName, IsOptional);
   return Container->Properties.emplace_back(std::move(Record)).get();
 }
 
 ObjCInstanceVariableRecord *APISet::addObjCInstanceVariable(
     ObjCContainerRecord *Container, StringRef Name, StringRef USR,
     PresumedLoc Loc, const AvailabilityInfo &Availability,
     const DocComment &Comment, DeclarationFragments Declaration,
     DeclarationFragments SubHeading,
     ObjCInstanceVariableRecord::AccessControl Access) {
   auto Record = std::make_unique<ObjCInstanceVariableRecord>(
-      Name, USR, Loc, Availability, Comment, Declaration, SubHeading, Access);
+      USR, Name, Loc, Availability, Comment, Declaration, SubHeading, Access);
   return Container->Ivars.emplace_back(std::move(Record)).get();
 }
 
 ObjCProtocolRecord *APISet::addObjCProtocol(
     StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading) {
-  return addTopLevelRecord(ObjCProtocols, Name, USR, Loc, Availability, Comment,
+  return addTopLevelRecord(ObjCProtocols, USR, Name, Loc, Availability, Comment,
                            Declaration, SubHeading);
 }
 
 MacroDefinitionRecord *
 APISet::addMacroDefinition(StringRef Name, StringRef USR, PresumedLoc Loc,
                            DeclarationFragments Declaration,
                            DeclarationFragments SubHeading) {
-  return addTopLevelRecord(Macros, Name, USR, Loc, Declaration, SubHeading);
+  return addTopLevelRecord(Macros, USR, Name, Loc, Declaration, SubHeading);
 }
 
 TypedefRecord *APISet::addTypedef(StringRef Name, StringRef USR,
                                   PresumedLoc Loc,
                                   const AvailabilityInfo &Availability,
                                   const DocComment &Comment,
                                   DeclarationFragments Declaration,
                                   DeclarationFragments SubHeading,
                                   SymbolReference UnderlyingType) {
-  return addTopLevelRecord(Typedefs, Name, USR, Loc, Availability, Comment,
+  return addTopLevelRecord(Typedefs, USR, Name, Loc, Availability, Comment,
                            Declaration, SubHeading, UnderlyingType);
 }
 
 StringRef APISet::recordUSR(const Decl *D) {
   SmallString<128> USR;
   index::generateUSRForDecl(D, USR);
   return copyString(USR);
 }

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

bool VisitEnumDecl(const EnumDecl *Decl) {
     // Skip forward declaration.
     if (!Decl->isThisDeclarationADefinition())
       return true;
 
     if (!LCF.isLocationInKnownFile(Decl->getLocation()))
       return true;
 
     // Collect symbol information.
-    StringRef Name = Decl->getName();
+    std::string NameString = Decl->getQualifiedNameAsString();
+    StringRef Name(NameString);
     if (Name.empty())
       Name = getTypedefName(Decl);
+
     StringRef USR = API.recordUSR(Decl);
     PresumedLoc Loc =
         Context.getSourceManager().getPresumedLoc(Decl->getLocation());
     AvailabilityInfo Availability = getAvailability(Decl);
     DocComment Comment;
     if (auto *RawComment = Context.getRawCommentForDeclNoCache(Decl))
       Comment = RawComment->getFormattedLines(Context.getSourceManager(),
                                               Context.getDiagnostics());
 
     // Build declaration fragments and sub-heading for the enum.
     DeclarationFragments Declaration =
         DeclarationFragmentsBuilder::getFragmentsForEnum(Decl);
     DeclarationFragments SubHeading =
         DeclarationFragmentsBuilder::getSubHeading(Decl);
 
-    EnumRecord *EnumRecord = API.addEnum(Name, USR, Loc, Availability, Comment,
-                                         Declaration, SubHeading);
+    EnumRecord *EnumRecord =
+        API.addEnum(API.copyString(Name), USR, Loc, Availability, Comment,
 
     // Now collect information about the enumerators in this enum.
     recordEnumConstants(EnumRecord, Decl->enumerators());
 
     return true;
   }
 
   bool VisitRecordDecl(const RecordDecl *Decl) {

clang/test/ExtractAPI/enum.c

 
 enum Direction : unsigned char {
   North = 0,
   East,
   South,
   West
 };
 
+enum {
+  Constant = 1
+};
+
+enum {
+  OtherConstant = 2
+};
+
 //--- reference.output.json.in
 {
   "metadata": {
     "formatVersion": {
       "major": 0,
       "minor": 5,
       "patch": 3
     },
"relationships": [
       "kind": "memberOf",
       "source": "c:@E@Direction@South",
       "target": "c:@E@Direction"
     },
     {
       "kind": "memberOf",
       "source": "c:@E@Direction@West",
       "target": "c:@E@Direction"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@Ea@Constant@Constant",
+      "target": "c:@Ea@Constant"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@Ea@OtherConstant@OtherConstant",
+      "target": "c:@Ea@OtherConstant"
     }
   ],
   "symbols": [
     {
       "accessLevel": "public",
       "declarationFragments": [
         {
           "kind": "keyword",
"symbols": [
           }
         ],
         "title": "West"
       },
       "pathComponents": [
         "Direction",
         "West"
       ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "enum"
+        },
+        {
+          "kind": "text",
+          "spelling": ": "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:i",
+          "spelling": "unsigned int"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c",
+        "precise": "c:@Ea@Constant"
+      },
+      "kind": {
+        "displayName": "Enumeration",
+        "identifier": "c.enum"
+      },
+      "location": {
+        "position": {
+          "character": 1,
+          "line": 17
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "(anonymous)"
+          }
+        ],
+        "title": "(anonymous)"
+      },
+      "pathComponents": [
+        "(anonymous)"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "identifier",
+          "spelling": "Constant"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c",
+        "precise": "c:@Ea@Constant@Constant"
+      },
+      "kind": {
+        "displayName": "Enumeration Case",
+        "identifier": "c.enum.case"
+      },
+      "location": {
+        "position": {
+          "character": 3,
+          "line": 18
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Constant"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Constant"
+          }
+        ],
+        "title": "Constant"
+      },
+      "pathComponents": [
+        "(anonymous)",
+        "Constant"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "enum"
+        },
+        {
+          "kind": "text",
+          "spelling": ": "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:i",
+          "spelling": "unsigned int"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c",
+        "precise": "c:@Ea@OtherConstant"
+      },
+      "kind": {
+        "displayName": "Enumeration",
+        "identifier": "c.enum"
+      },
+      "location": {
+        "position": {
+          "character": 1,
+          "line": 21
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "(anonymous)"
+          }
+        ],
+        "title": "(anonymous)"
+      },
+      "pathComponents": [
+        "(anonymous)"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "identifier",
+          "spelling": "OtherConstant"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c",
+        "precise": "c:@Ea@OtherConstant@OtherConstant"
+      },
+      "kind": {
+        "displayName": "Enumeration Case",
+        "identifier": "c.enum.case"
+      },
+      "location": {
+        "position": {
+          "character": 3,
+          "line": 22
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "OtherConstant"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "OtherConstant"
+          }
+        ],
+        "title": "OtherConstant"
+      },
+      "pathComponents": [
+        "(anonymous)",
+        "OtherConstant"
+      ]
     }
   ]
 }