[clang][ExtractAPI] Refactor C++ method and field visitation

[evelez7]

Summary

Refactor visitation for C++ record children by following the Visitor's CRTP.
Expand VisitCXXField, VisitCXXMethod for non-templates and introduce VisitCXXConstructor, VisitCXXDestructor.
Handle relationships by finding the parent's Record via USR from DeclContext.

Depends on D158029

[evelez7]

Fix passing Decl's template, introduced from parent updates

[dang]

Did this change not affect ordering of the symbols in the generated JSON? Looks pretty good to me otherwise!

[evelez7]

In D158031#4603363, @dang wrote:

Did this change not affect ordering of the symbols in the generated JSON? Looks pretty good to me otherwise!

It only changed method ordering due to them not being grouped together, so instance methods always appear before static methods now.

clang/include/clang/ExtractAPI/API.h

 template <>
 struct has_function_signature<ObjCMethodRecord> : public std::true_type {};
 template <>
 struct has_function_signature<ObjCInstanceMethodRecord>
     : public std::true_type {};
 template <>
 struct has_function_signature<ObjCClassMethodRecord> : public std::true_type {};
 template <>
-struct has_function_signature<CXXMethodRecord> : public std::true_type {};
+struct has_function_signature<CXXInstanceMethodRecord> : public std::true_type {};
+template <>
+struct has_function_signature<CXXStaticMethodRecord> : public std::true_type {};
 template <>
 struct has_function_signature<GlobalFunctionTemplateRecord>
     : public std::true_type {};
 template <>
 struct has_function_signature<GlobalFunctionTemplateSpecializationRecord>
     : public std::true_type {};
 template <>
 struct has_function_signature<CXXMethodTemplateRecord> : public std::true_type {
 };
 template <>
 struct has_function_signature<CXXMethodTemplateSpecializationRecord>
     : public std::true_type {};
 
 template <typename RecordTy> struct has_access : public std::false_type {};
-template <> struct has_access<CXXMethodRecord> : public std::true_type {};
+template <> struct has_access<CXXInstanceMethodRecord> : public std::true_type {};
+template <> struct has_access<CXXStaticMethodRecord> : public std::true_type {};
 template <> struct has_access<CXXFieldRecord> : public std::true_type {};
 template <>
 struct has_access<CXXMethodTemplateRecord> : public std::true_type {};
 template <>
 struct has_access<CXXMethodTemplateSpecializationRecord>
     : public std::true_type {};
 template <>
 struct has_access<CXXFieldTemplateRecord> : public std::true_type {};
public:
 
   StaticFieldRecord *
   addStaticField(StringRef Name, StringRef USR, PresumedLoc Loc,
                  AvailabilitySet Availabilities, LinkageInfo Linkage,
                  const DocComment &Comment, DeclarationFragments Declaration,
                  DeclarationFragments SubHeading, SymbolReference Context,
                  AccessControl Access, bool IsFromSystemHeaderg);
 
-  CXXFieldRecord *addCXXField(CXXClassRecord *CXXClass, StringRef Name,
+  CXXFieldRecord *addCXXField(APIRecord *CXXClass, StringRef Name,
                               StringRef USR, PresumedLoc Loc,
                               AvailabilitySet Availabilities,
                               const DocComment &Comment,
                               DeclarationFragments Declaration,
                               DeclarationFragments SubHeading,
                               AccessControl Access, bool IsFromSystemHeader);
 
   CXXFieldTemplateRecord *addCXXFieldTemplate(
public:
   GlobalVariableTemplatePartialSpecializationRecord *
   addGlobalVariableTemplatePartialSpecialization(
       StringRef Name, StringRef USR, PresumedLoc Loc,
       AvailabilitySet Availability, LinkageInfo Linkage,
       const DocComment &Comment, DeclarationFragments Declaration,
       DeclarationFragments SubHeading, Template Template,
       bool IsFromSystemHeader);
 
-  CXXMethodRecord *
-  addCXXMethod(CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
-               PresumedLoc Loc, AvailabilitySet Availability,
-               const DocComment &Comment, DeclarationFragments Declaration,
-               DeclarationFragments SubHeading, FunctionSignature Signature,
-               bool IsStatic, AccessControl Access, bool IsFromSystemHeader);
+  CXXMethodRecord *addCXXInstanceMethod(
+      APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
+      AvailabilitySet Availability, const DocComment &Comment,
+      DeclarationFragments Declaration, DeclarationFragments SubHeading,
+      FunctionSignature Signature, AccessControl Access,
+      bool IsFromSystemHeader);
+
+  CXXMethodRecord *addCXXStaticMethod(
+      APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
+      AvailabilitySet Availability, const DocComment &Comment,
+      DeclarationFragments Declaration, DeclarationFragments SubHeading,
+      FunctionSignature Signature, AccessControl Access,
+      bool IsFromSystemHeader);
 
   CXXMethodRecord *addCXXSpecialMethod(
-      CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
-      PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,
+      APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
+      AvailabilitySet Availability, const DocComment &Comment,
       DeclarationFragments Declaration, DeclarationFragments SubHeading,
-      FunctionSignature Signature, bool IsConstructor, AccessControl Access,
+      FunctionSignature Signature, AccessControl Access,
       bool IsFromSystemHeader);
 
   CXXMethodTemplateRecord *addCXXMethodTemplate(
       APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
       AvailabilitySet Availability, const DocComment &Comment,
       DeclarationFragments Declaration, DeclarationFragments SubHeading,
       FunctionSignature Signature, AccessControl Access, Template Template,
       bool IsFromSystemHeader);
getGlobalVariableTemplatePartialSpecializations() const {
     return GlobalVariableTemplatePartialSpecializations;
   }
   const RecordMap<EnumRecord> &getEnums() const { return Enums; }
   const RecordMap<StructRecord> &getStructs() const { return Structs; }
   const RecordMap<CXXClassRecord> &getCXXClasses() const { return CXXClasses; }
   const RecordMap<CXXMethodTemplateRecord> &getCXXMethodTemplates() const {
     return CXXMethodTemplates;
   }
+  const RecordMap<CXXInstanceMethodRecord> &getCXXInstanceMethods() const {
+    return CXXInstanceMethods;
+  }
+  const RecordMap<CXXStaticMethodRecord> &getCXXStaticMethods() const {
+    return CXXStaticMethods;
+  }
+  const RecordMap<CXXFieldRecord> &getCXXFields() const { return CXXFields; }
   const RecordMap<CXXMethodTemplateSpecializationRecord> &
   getCXXMethodTemplateSpecializations() const {
     return CXXMethodTemplateSpecializations;
   }
   const RecordMap<CXXFieldTemplateRecord> &getCXXFieldTemplates() const {
     return CXXFieldTemplates;
   }
   const RecordMap<ConceptRecord> &getConcepts() const { return Concepts; }
RecordMap<GlobalVariableTemplateSpecializationRecord>
       GlobalVariableTemplateSpecializations;
   RecordMap<GlobalVariableTemplatePartialSpecializationRecord>
       GlobalVariableTemplatePartialSpecializations;
   RecordMap<ConceptRecord> Concepts;
   RecordMap<StaticFieldRecord> StaticFields;
   RecordMap<EnumRecord> Enums;
   RecordMap<StructRecord> Structs;
   RecordMap<CXXClassRecord> CXXClasses;
+  RecordMap<CXXFieldRecord> CXXFields;
+  RecordMap<CXXMethodRecord> CXXMethods;
+  RecordMap<CXXInstanceMethodRecord> CXXInstanceMethods;
+  RecordMap<CXXStaticMethodRecord> CXXStaticMethods;
   RecordMap<CXXMethodTemplateRecord> CXXMethodTemplates;
   RecordMap<CXXMethodTemplateSpecializationRecord>
       CXXMethodTemplateSpecializations;
   RecordMap<CXXFieldTemplateRecord> CXXFieldTemplates;
   RecordMap<ClassTemplateRecord> ClassTemplates;
   RecordMap<ClassTemplateSpecializationRecord> ClassTemplateSpecializations;
   RecordMap<ClassTemplatePartialSpecializationRecord>
       ClassTemplatePartialSpecializations;

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

public:
   const APISet &getAPI() const { return API; }
 
   bool VisitVarDecl(const VarDecl *Decl);
 
   bool VisitFunctionDecl(const FunctionDecl *Decl);
 
   bool VisitEnumDecl(const EnumDecl *Decl);
 
+  bool WalkUpFromFunctionDecl(const FunctionDecl *Decl);
+
   bool WalkUpFromRecordDecl(const RecordDecl *Decl);
 
   bool WalkUpFromCXXRecordDecl(const CXXRecordDecl *Decl);
 
   bool WalkUpFromCXXMethodDecl(const CXXMethodDecl *Decl);
 
   bool WalkUpFromClassTemplateSpecializationDecl(
       const ClassTemplateSpecializationDecl *Decl);
public:
   bool WalkUpFromFunctionTemplateDecl(const FunctionTemplateDecl *Decl);
 
   bool VisitRecordDecl(const RecordDecl *Decl);
 
   bool VisitCXXRecordDecl(const CXXRecordDecl *Decl);
 
   bool VisitCXXMethodDecl(const CXXMethodDecl *Decl);
 
+  bool VisitFieldDecl(const FieldDecl *Decl);
+
+  bool VisitCXXConversionDecl(const CXXConversionDecl *Decl);
+
+  bool VisitCXXConstructorDecl(const CXXConstructorDecl *Decl);
+
+  bool VisitCXXDestructorDecl(const CXXDestructorDecl *Decl);
+
   bool VisitConceptDecl(const ConceptDecl *Decl);
 
   bool VisitClassTemplateSpecializationDecl(
       const ClassTemplateSpecializationDecl *Decl);
 
   bool VisitClassTemplatePartialSpecializationDecl(
       const ClassTemplatePartialSpecializationDecl *Decl);
 
protected:
   void recordEnumConstants(EnumRecord *EnumRecord,
                            const EnumDecl::enumerator_range Constants);
 
   /// Collect API information for the struct fields and associate with the
   /// parent struct.
   void recordStructFields(StructRecord *StructRecord,
                           const RecordDecl::field_range Fields);
 
-  /// Collect API information for the class fields and associate with the parent
-  /// struct
-  void recordCXXFields(CXXClassRecord *CXXClassRecord,
-                       const RecordDecl::field_range Fields);
-
-  void recordCXXMethods(CXXClassRecord *CXXClassRecord,
-                        const CXXRecordDecl::method_range Methods);
-
-  void recordConversionMethod(CXXClassRecord *CXXClassRecord,
-                              const CXXMethodDecl *SpecialCXXMethod);
-
-  void recordSpecialCXXMethod(CXXClassRecord *CXXClassRecord,
-                              const CXXMethodDecl *SpecialCXXMethod);
-
   /// Collect API information for the Objective-C methods and associate with the
   /// parent container.
   void recordObjCMethods(ObjCContainerRecord *Container,
                          const ObjCContainerDecl::method_range Methods);
 
   void recordObjCProperties(ObjCContainerRecord *Container,
                             const ObjCContainerDecl::prop_range Properties);
 
bool ExtractAPIVisitorBase<Derived>::VisitEnumDecl(const EnumDecl *Decl) {
   // Now collect information about the enumerators in this enum.
   getDerivedExtractAPIVisitor().recordEnumConstants(EnumRecord,
                                                     Decl->enumerators());
 
   return true;
 }
 
 template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::WalkUpFromFunctionDecl(
+    const FunctionDecl *Decl) {
+  getDerivedExtractAPIVisitor().VisitFunctionDecl(Decl);
+  return true;
+}
+
+template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::WalkUpFromRecordDecl(
     const RecordDecl *Decl) {
   getDerivedExtractAPIVisitor().VisitRecordDecl(Decl);
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::WalkUpFromCXXRecordDecl(
CXXClassRecord = API.addClassTemplate(
         Template(Decl->getDescribedClassTemplate()), isInSystemHeader(Decl));
   } else
     CXXClassRecord =
         API.addCXXClass(Name, USR, Loc, AvailabilitySet(Decl), Comment,
                         Declaration, SubHeading, Kind, isInSystemHeader(Decl));
 
   CXXClassRecord->Bases = getBases(Decl);
 
-  getDerivedExtractAPIVisitor().recordCXXFields(CXXClassRecord, Decl->fields());
-  getDerivedExtractAPIVisitor().recordCXXMethods(CXXClassRecord,
-                                                 Decl->methods());
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitCXXMethodDecl(
     const CXXMethodDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl) ||
       Decl->isImplicit())
     return true;
-  switch (Decl->getTemplatedKind()) {
-  case FunctionDecl::TK_MemberSpecialization:
-  case FunctionDecl::TK_FunctionTemplateSpecialization:
-  case FunctionDecl::TK_FunctionTemplate:
-  case FunctionDecl::TK_DependentFunctionTemplateSpecialization:
-    break;
-  case FunctionDecl::TK_NonTemplate:
-  case FunctionDecl::TK_DependentNonTemplate:
+
+  if (isa<CXXConversionDecl>(Decl))
+    return true;
+  if (isa<CXXConstructorDecl>(Decl) || isa<CXXDestructorDecl>(Decl))
     return true;
-  }
 
-  StringRef Name = Decl->getName();
   StringRef USR = API.recordUSR(Decl);
   PresumedLoc Loc =
       Context.getSourceManager().getPresumedLoc(Decl->getLocation());
   DocComment Comment;
   if (auto *RawComment =
           getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
     Comment = RawComment->getFormattedLines(Context.getSourceManager(),
                                             Context.getDiagnostics());
   DeclarationFragments SubHeading =
       DeclarationFragmentsBuilder::getSubHeading(Decl);
+  auto Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
+  auto Signature = DeclarationFragmentsBuilder::getFunctionSignature(Decl);
 
   SmallString<128> ParentUSR;
   index::generateUSRForDecl(dyn_cast<CXXRecordDecl>(Decl->getDeclContext()),
                             ParentUSR);
+  auto *Parent = API.findRecordForUSR(ParentUSR);
   if (Decl->isTemplated()) {
     FunctionTemplateDecl *TemplateDecl = Decl->getDescribedFunctionTemplate();
     API.addCXXMethodTemplate(
-        API.findRecordForUSR(ParentUSR), Name, USR, Loc, AvailabilitySet(Decl),
-        Comment,
+        API.findRecordForUSR(ParentUSR), Decl->getName(), USR, Loc,
+        AvailabilitySet(Decl), Comment,
         DeclarationFragmentsBuilder::getFragmentsForFunctionTemplate(
             TemplateDecl),
         SubHeading, DeclarationFragmentsBuilder::getFunctionSignature(Decl),
         DeclarationFragmentsBuilder::getAccessControl(TemplateDecl),
         Template(TemplateDecl), isInSystemHeader(Decl));
   } else if (Decl->getTemplateSpecializationInfo())
     API.addCXXMethodTemplateSpec(
-        API.findRecordForUSR(ParentUSR), Name, USR, Loc, AvailabilitySet(Decl),
-        Comment,
+        Parent, Decl->getName(), USR, Loc, AvailabilitySet(Decl), Comment,
         DeclarationFragmentsBuilder::
             getFragmentsForFunctionTemplateSpecialization(Decl),
-        SubHeading, DeclarationFragmentsBuilder::getFunctionSignature(Decl),
-        DeclarationFragmentsBuilder::getAccessControl(Decl),
+        SubHeading, Signature, Access, isInSystemHeader(Decl));
+  else if (Decl->isOverloadedOperator())
+    API.addCXXInstanceMethod(
+        Parent, API.copyString(Decl->getNameAsString()), USR, Loc,
+        AvailabilitySet(Decl), Comment,
+        DeclarationFragmentsBuilder::getFragmentsForOverloadedOperator(Decl),
+        SubHeading, Signature, Access, isInSystemHeader(Decl));
+  else if (Decl->isStatic())
+    API.addCXXStaticMethod(
+        Parent, Decl->getName(), USR, Loc, AvailabilitySet(Decl), Comment,
+        DeclarationFragmentsBuilder::getFragmentsForCXXMethod(Decl), SubHeading,
+        Signature, Access, isInSystemHeader(Decl));
+  else
+    API.addCXXInstanceMethod(
+        Parent, Decl->getName(), USR, Loc, AvailabilitySet(Decl), Comment,
+        DeclarationFragmentsBuilder::getFragmentsForCXXMethod(Decl), SubHeading,
+        Signature, Access, isInSystemHeader(Decl));
+
+  return true;
+}
+
+template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::VisitCXXConstructorDecl(
+    const CXXConstructorDecl *Decl) {
+
+  StringRef Name = API.copyString(Decl->getNameAsString());
+  StringRef USR = API.recordUSR(Decl);
+  PresumedLoc Loc =
+      Context.getSourceManager().getPresumedLoc(Decl->getLocation());
+  DocComment Comment;
+  if (auto *RawComment =
+          getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
+    Comment = RawComment->getFormattedLines(Context.getSourceManager(),
+                                            Context.getDiagnostics());
+
+  // Build declaration fragments, sub-heading, and signature for the method.
+  DeclarationFragments Declaration =
+      DeclarationFragmentsBuilder::getFragmentsForSpecialCXXMethod(Decl);
+  DeclarationFragments SubHeading =
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+  FunctionSignature Signature =
+      DeclarationFragmentsBuilder::getFunctionSignature(Decl);
+  AccessControl Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
+
+  SmallString<128> ParentUSR;
+  index::generateUSRForDecl(dyn_cast<CXXRecordDecl>(Decl->getDeclContext()),
+                            ParentUSR);
+  API.addCXXInstanceMethod(API.findRecordForUSR(ParentUSR), Name, USR, Loc,
+                           AvailabilitySet(Decl), Comment, Declaration,
+                           SubHeading, Signature, Access,
+                           isInSystemHeader(Decl));
+  return true;
+}
+
+template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::VisitCXXDestructorDecl(
+    const CXXDestructorDecl *Decl) {
+
+  StringRef Name = API.copyString(Decl->getNameAsString());
+  StringRef USR = API.recordUSR(Decl);
+  PresumedLoc Loc =
+      Context.getSourceManager().getPresumedLoc(Decl->getLocation());
+  DocComment Comment;
+  if (auto *RawComment =
+          getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
+    Comment = RawComment->getFormattedLines(Context.getSourceManager(),
+                                            Context.getDiagnostics());
+
+  // Build declaration fragments, sub-heading, and signature for the method.
+  DeclarationFragments Declaration =
+      DeclarationFragmentsBuilder::getFragmentsForSpecialCXXMethod(Decl);
+  DeclarationFragments SubHeading =
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+  FunctionSignature Signature =
+      DeclarationFragmentsBuilder::getFunctionSignature(Decl);
+  AccessControl Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
+
+  SmallString<128> ParentUSR;
+  index::generateUSRForDecl(dyn_cast<CXXRecordDecl>(Decl->getDeclContext()),
+                            ParentUSR);
+  API.addCXXInstanceMethod(API.findRecordForUSR(ParentUSR), Name, USR, Loc,
+                           AvailabilitySet(Decl), Comment, Declaration,
+                           SubHeading, Signature, Access,
                            isInSystemHeader(Decl));
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitConceptDecl(const ConceptDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
 
bool ExtractAPIVisitorBase<Derived>::VisitClassTemplateSpecializationDecl(
   DeclarationFragments SubHeading =
       DeclarationFragmentsBuilder::getSubHeading(Decl);
 
   auto *ClassTemplateSpecializationRecord = API.addClassTemplateSpecialization(
       Name, USR, Loc, AvailabilitySet(Decl), Comment, Declaration, SubHeading,
       isInSystemHeader(Decl));
 
   ClassTemplateSpecializationRecord->Bases = getBases(Decl);
-  getDerivedExtractAPIVisitor().recordCXXFields(
-      ClassTemplateSpecializationRecord, Decl->fields());
-  getDerivedExtractAPIVisitor().recordCXXMethods(
-      ClassTemplateSpecializationRecord, Decl->methods());
+
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::
     VisitClassTemplatePartialSpecializationDecl(
         const ClassTemplatePartialSpecializationDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
bool ExtractAPIVisitorBase<Derived>::
 
   auto *ClassTemplatePartialSpecRecord =
       API.addClassTemplatePartialSpecialization(
           Name, USR, Loc, AvailabilitySet(Decl), Comment, Declaration,
           SubHeading, Template(Decl), isInSystemHeader(Decl));
 
   ClassTemplatePartialSpecRecord->Bases = getBases(Decl);
 
-  getDerivedExtractAPIVisitor().recordCXXFields(ClassTemplatePartialSpecRecord,
-                                                Decl->fields());
-  getDerivedExtractAPIVisitor().recordCXXMethods(ClassTemplatePartialSpecRecord,
-                                                 Decl->methods());
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitVarTemplateDecl(
     const VarTemplateDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
for (const auto *Field : Fields) {
 
     API.addStructField(StructRecord, Name, USR, Loc, AvailabilitySet(Field),
                        Comment, Declaration, SubHeading,
                        isInSystemHeader(Field));
   }
 }
 
 template <typename Derived>
-void ExtractAPIVisitorBase<Derived>::recordCXXFields(
-    CXXClassRecord *CXXClassRecord, const RecordDecl::field_range Fields) {
-  for (const auto *Field : Fields) {
-    // Collect symbol information.
-    StringRef Name = Field->getName();
-    StringRef USR = API.recordUSR(Field);
-    PresumedLoc Loc =
-        Context.getSourceManager().getPresumedLoc(Field->getLocation());
-    Context.getSourceManager().getPresumedLoc(Field->getLocation());
-    DocComment Comment;
-    if (auto *RawComment =
-            getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Field))
-      Comment = RawComment->getFormattedLines(Context.getSourceManager(),
-                                              Context.getDiagnostics());
+bool ExtractAPIVisitorBase<Derived>::VisitFieldDecl(const FieldDecl *Decl) {
+  if (Decl->getDeclContext()->getDeclKind() == Decl::Record)
+    return true;
+  if (isa<ObjCIvarDecl>(Decl))
+    return true;
+  StringRef Name = Decl->getName();
+  StringRef USR = API.recordUSR(Decl);
+      Context.getSourceManager().getPresumedLoc(Decl->getLocation());
+          getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
 
-    // Build declaration fragments and sub-heading for the struct field.
-    DeclarationFragments Declaration =
-        DeclarationFragmentsBuilder::getFragmentsForField(Field);
-    DeclarationFragments SubHeading =
-        DeclarationFragmentsBuilder::getSubHeading(Field);
-    AccessControl Access = DeclarationFragmentsBuilder::getAccessControl(Field);
-
-    API.addCXXField(CXXClassRecord, Name, USR, Loc, AvailabilitySet(Field),
-                    Comment, Declaration, SubHeading, Access,
-                    isInSystemHeader(Field));
-  }
-}
-
-/// Collect API information for constructors and destructors and associate with
-/// the parent class.
-template <typename Derived>
-void ExtractAPIVisitorBase<Derived>::recordSpecialCXXMethod(
-    CXXClassRecord *CXXClassRecord, const CXXMethodDecl *CXXSpecialMethod) {
-  StringRef Name;
-  bool isConstructor = false;
-  if (isa<CXXConstructorDecl>(CXXSpecialMethod)) {
-    isConstructor = true;
-    Name = CXXClassRecord->Name;
-  } else if (isa<CXXDestructorDecl>(CXXSpecialMethod)) {
-    // Copy string to get name with '~'.
-    Name = API.copyString(CXXSpecialMethod->getNameAsString());
-  }
-
-  StringRef USR = API.recordUSR(CXXSpecialMethod);
-  PresumedLoc Loc = Context.getSourceManager().getPresumedLoc(
-      CXXSpecialMethod->getLocation());
-  DocComment Comment;
-  if (auto *RawComment = getDerivedExtractAPIVisitor().fetchRawCommentForDecl(
-          CXXSpecialMethod))
-    Comment = RawComment->getFormattedLines(Context.getSourceManager(),
-                                            Context.getDiagnostics());
-
-  // Build declaration fragments, sub-heading, and signature for the method.
-  DeclarationFragments Declaration =
-      DeclarationFragmentsBuilder::getFragmentsForSpecialCXXMethod(
-          CXXSpecialMethod);
-  DeclarationFragments SubHeading =
-      DeclarationFragmentsBuilder::getSubHeading(CXXSpecialMethod);
-  FunctionSignature Signature =
-      DeclarationFragmentsBuilder::getFunctionSignature(CXXSpecialMethod);
-  AccessControl Access =
-      DeclarationFragmentsBuilder::getAccessControl(CXXSpecialMethod);
-
-  API.addCXXSpecialMethod(CXXClassRecord, Name, USR, Loc,
-                          AvailabilitySet(CXXSpecialMethod), Comment,
-                          Declaration, SubHeading, Signature, isConstructor,
-                          Access, isInSystemHeader(CXXSpecialMethod));
-}
-
-template <typename Derived>
-void ExtractAPIVisitorBase<Derived>::recordConversionMethod(
-    CXXClassRecord *CXXClassRecord, const CXXMethodDecl *SpecialCXXMethod) {
-  StringRef Name = API.copyString(SpecialCXXMethod->getNameAsString());
-  StringRef USR = API.recordUSR(SpecialCXXMethod);
-  PresumedLoc Loc = Context.getSourceManager().getPresumedLoc(
-      SpecialCXXMethod->getLocation());
-  DocComment Comment;
-  if (auto *RawComment = getDerivedExtractAPIVisitor().fetchRawCommentForDecl(
-          SpecialCXXMethod))
-    Comment = RawComment->getFormattedLines(Context.getSourceManager(),
-                                            Context.getDiagnostics());
-
-  // Build declaration fragments, sub-heading, and signature for the method.
-  DeclarationFragments Declaration =
-      DeclarationFragmentsBuilder::getFragmentsForConversionFunction(
-          cast<CXXConversionDecl>(SpecialCXXMethod));
+      DeclarationFragmentsBuilder::getFragmentsForField(Decl);
   DeclarationFragments SubHeading =
-      DeclarationFragmentsBuilder::getSubHeading(SpecialCXXMethod);
-  FunctionSignature Signature =
-      DeclarationFragmentsBuilder::getFunctionSignature(SpecialCXXMethod);
-  AccessControl Access =
-      DeclarationFragmentsBuilder::getAccessControl(SpecialCXXMethod);
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+  AccessControl Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
 
-  API.addCXXMethod(CXXClassRecord, Name, USR, Loc,
-                   AvailabilitySet(SpecialCXXMethod), Comment, Declaration,
-                   SubHeading, Signature, SpecialCXXMethod->isStatic(), Access,
-                   isInSystemHeader(SpecialCXXMethod));
+  SmallString<128> ParentUSR;
+  index::generateUSRForDecl(dyn_cast<CXXRecordDecl>(Decl->getDeclContext()),
+                            ParentUSR);
+  API.addCXXField(API.findRecordForUSR(ParentUSR), Name, USR, Loc,
+                  AvailabilitySet(Decl), Comment, Declaration, SubHeading,
+                  Access, isInSystemHeader(Decl));
+  return true;
 }
 
 template <typename Derived>
-void ExtractAPIVisitorBase<Derived>::recordCXXMethods(
-    CXXClassRecord *CXXClassRecord, const CXXRecordDecl::method_range Methods) {
-  for (const auto *Method : Methods) {
-    if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method)) {
-      recordSpecialCXXMethod(CXXClassRecord, Method);
-      continue;
-    }
-
-    if (isa<CXXConversionDecl>(Method)) {
-      recordConversionMethod(CXXClassRecord, Method);
-      continue;
-    }
-
-    if (Method->isFunctionTemplateSpecialization())
-      return;
-
-    StringRef Name;
-    DeclarationFragments Declaration;
-    if (Method->isOverloadedOperator()) {
-      Name = API.copyString(Method->getNameAsString());
-      Declaration =
-          DeclarationFragmentsBuilder::getFragmentsForOverloadedOperator(
-              Method);
-    } else {
-      Name = API.copyString(Method->getNameAsString());
-      Declaration =
-          DeclarationFragmentsBuilder::getFragmentsForCXXMethod(Method);
-    }
-    StringRef USR = API.recordUSR(Method);
-    PresumedLoc Loc =
-        Context.getSourceManager().getPresumedLoc(Method->getLocation());
-    DocComment Comment;
-    if (auto *RawComment =
-            getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Method))
-      Comment = RawComment->getFormattedLines(Context.getSourceManager(),
-                                              Context.getDiagnostics());
+bool ExtractAPIVisitorBase<Derived>::VisitCXXConversionDecl(
+    const CXXConversionDecl *Decl) {
+  StringRef Name = API.copyString(Decl->getNameAsString());
+  StringRef USR = API.recordUSR(Decl);
+      Context.getSourceManager().getPresumedLoc(Decl->getLocation());
+          getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
 
-    // Build declaration fragments, sub-heading, and signature for the method.
-    DeclarationFragments SubHeading =
-        DeclarationFragmentsBuilder::getSubHeading(Method);
-    FunctionSignature Signature =
-        DeclarationFragmentsBuilder::getFunctionSignature(Method);
-    AccessControl Access =
-        DeclarationFragmentsBuilder::getAccessControl(Method);
+  DeclarationFragments Declaration =
+      DeclarationFragmentsBuilder::getFragmentsForConversionFunction(Decl);
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+      DeclarationFragmentsBuilder::getFunctionSignature(Decl);
+  AccessControl Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
 
-    API.addCXXMethod(CXXClassRecord, Name, USR, Loc, AvailabilitySet(Method),
-                     Comment, Declaration, SubHeading, Signature,
-                     Method->isStatic(), Access, isInSystemHeader(Method));
-  }
+  SmallString<128> ParentUSR;
+  index::generateUSRForDecl(dyn_cast<CXXRecordDecl>(Decl->getDeclContext()),
+                            ParentUSR);
+  if (Decl->isStatic())
+    API.addCXXStaticMethod(API.findRecordForUSR(ParentUSR), Name, USR, Loc,
+                           AvailabilitySet(Decl), Comment, Declaration,
+                           SubHeading, Signature, Access,
+                           isInSystemHeader(Decl));
+  else
+    API.addCXXInstanceMethod(API.findRecordForUSR(ParentUSR), Name, USR, Loc,
+                             AvailabilitySet(Decl), Comment, Declaration,
+                             SubHeading, Signature, Access,
+                             isInSystemHeader(Decl));
+  return true;
 }
 
 /// Collect API information for the Objective-C methods and associate with the
 /// parent container.
 template <typename Derived>
 void ExtractAPIVisitorBase<Derived>::recordObjCMethods(
     ObjCContainerRecord *Container,
     const ObjCContainerDecl::method_range Methods) {

clang/include/clang/ExtractAPI/Serialization/SerializerBase.h

void traverseAPISet() {
     getDerived()->traverseCXXClassRecords();
 
     getDerived()->traverseClassTemplateRecords();
 
     getDerived()->traverseClassTemplateSpecializationRecords();
 
     getDerived()->traverseClassTemplatePartialSpecializationRecords();
 
+    getDerived()->traverseCXXInstanceMethods();
+
+    getDerived()->traverseCXXStaticMethods();
+
     getDerived()->traverseCXXMethodTemplates();
 
     getDerived()->traverseCXXMethodTemplateSpecializations();
 
+    getDerived()->traverseCXXFields();
+
     getDerived()->traverseCXXFieldTemplates();
 
     getDerived()->traverseConcepts();
 
     getDerived()->traverseGlobalVariableTemplateRecords();
 
     getDerived()->traverseGlobalVariableTemplateSpecializationRecords();
 
public:
 
   void traverseClassTemplatePartialSpecializationRecords() {
     for (const auto &ClassTemplatePartialSpecialization :
          API.getClassTemplatePartialSpecializations())
       getDerived()->visitClassTemplatePartialSpecializationRecord(
           *ClassTemplatePartialSpecialization.second);
   }
 
+  void traverseCXXInstanceMethods() {
+    for (const auto &InstanceMethod : API.getCXXInstanceMethods())
+      getDerived()->visitCXXInstanceMethodRecord(*InstanceMethod.second);
+  }
+
+  void traverseCXXStaticMethods() {
+    for (const auto &InstanceMethod : API.getCXXStaticMethods())
+      getDerived()->visitCXXStaticMethodRecord(*InstanceMethod.second);
+  }
+
+  void traverseCXXFields() {
+    for (const auto &CXXField : API.getCXXFields())
+      getDerived()->visitCXXFieldRecord(*CXXField.second);
+  }
+
   void traverseCXXFieldTemplates() {
     for (const auto &CXXFieldTemplate : API.getCXXFieldTemplates())
       getDerived()->visitCXXFieldTemplateRecord(*CXXFieldTemplate.second);
   }
 
   void traverseGlobalVariableTemplateRecords() {
     for (const auto &GlobalVariableTemplate : API.getGlobalVariableTemplates())
       getDerived()->visitGlobalVariableTemplateRecord(
public:
   void visitClassTemplateRecord(const ClassTemplateRecord &Record){};
 
   void visitClassTemplateSpecializationRecord(
       const ClassTemplateSpecializationRecord &Record){};
 
   void visitClassTemplatePartialSpecializationRecord(
       const ClassTemplatePartialSpecializationRecord &Record){};
 
+  void visitCXXInstanceRecord(const CXXInstanceMethodRecord &Record){};
+
+  void visitCXXStaticRecord(const CXXStaticMethodRecord &Record){};
+
   void visitMethodTemplateRecord(const CXXMethodTemplateRecord &Record){};
 
   void visitMethodTemplateSpecializationRecord(
       const CXXMethodTemplateSpecializationRecord &Record){};
 
   void visitCXXFieldTemplateRecord(const CXXFieldTemplateRecord &Record){};
 
   void visitGlobalVariableTemplateRecord(

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

public:
   void visitClassTemplateRecord(const ClassTemplateRecord &Record);
 
   void visitClassTemplateSpecializationRecord(
       const ClassTemplateSpecializationRecord &Record);
 
   void visitClassTemplatePartialSpecializationRecord(
       const ClassTemplatePartialSpecializationRecord &Record);
 
+  void visitCXXInstanceMethodRecord(const CXXInstanceMethodRecord &Record);
+
+  void visitCXXStaticMethodRecord(const CXXStaticMethodRecord &Record);
+
   void visitMethodTemplateRecord(const CXXMethodTemplateRecord &Record);
 
   void visitMethodTemplateSpecializationRecord(
       const CXXMethodTemplateSpecializationRecord &Record);
 
+  void visitCXXFieldRecord(const CXXFieldRecord &Record);
+
   void visitCXXFieldTemplateRecord(const CXXFieldTemplateRecord &Record);
 
   void visitConceptRecord(const ConceptRecord &Record);
 
   void
   visitGlobalVariableTemplateRecord(const GlobalVariableTemplateRecord &Record);
 
   void visitGlobalVariableTemplateSpecializationRecord(

clang/lib/ExtractAPI/API.cpp

APISet::addStaticField(StringRef Name, StringRef USR, PresumedLoc Loc,
                        AccessControl Access, bool IsFromSystemHeader) {
   return addTopLevelRecord(USRBasedLookupTable, StaticFields, USR, Name, Loc,
                            std::move(Availabilities), Linkage, Comment,
                            Declaration, SubHeading, Context, Access,
                            IsFromSystemHeader);
 }
 
 CXXFieldRecord *
-APISet::addCXXField(CXXClassRecord *CXXClass, StringRef Name, StringRef USR,
+APISet::addCXXField(APIRecord *CXXClass, StringRef Name, StringRef USR,
                     PresumedLoc Loc, AvailabilitySet Availabilities,
                     const DocComment &Comment, DeclarationFragments Declaration,
                     DeclarationFragments SubHeading, AccessControl Access,
                     bool IsFromSystemHeader) {
-  auto Record = std::make_unique<CXXFieldRecord>(
-      USR, Name, Loc, std::move(Availabilities), Comment, Declaration,
-      SubHeading, Access, IsFromSystemHeader);
+  auto *Record = addTopLevelRecord(
+      USRBasedLookupTable, CXXFields, USR, Name, Loc, std::move(Availabilities),
+      Comment, Declaration, SubHeading, Access, IsFromSystemHeader);
   Record->ParentInformation = APIRecord::HierarchyInformation(
       CXXClass->USR, CXXClass->Name, CXXClass->getKind(), CXXClass);
-  USRBasedLookupTable.insert({USR, Record.get()});
-  return CXXClass->Fields.emplace_back(std::move(Record)).get();
+  return Record;
 }
 
 CXXFieldTemplateRecord *APISet::addCXXFieldTemplate(
     APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
     AvailabilitySet Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading,
     AccessControl Access, Template Template, bool IsFromSystemHeader) {
   auto *Record =
ConceptRecord *APISet::addConcept(StringRef Name, StringRef USR,
                                   DeclarationFragments Declaration,
                                   DeclarationFragments SubHeading,
                                   Template Template, bool IsFromSystemHeader) {
   return addTopLevelRecord(USRBasedLookupTable, Concepts, USR, Name, Loc,
                            std::move(Availability), Comment, Declaration,
                            SubHeading, Template, IsFromSystemHeader);
 }
 
-CXXMethodRecord *APISet::addCXXMethod(
-    CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
-    PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,
-    DeclarationFragments Declaration, DeclarationFragments SubHeading,
-    FunctionSignature Signature, bool IsStatic, AccessControl Access,
-    bool IsFromSystemHeader) {
-  std::unique_ptr<CXXMethodRecord> Record;
-  if (IsStatic)
-    Record = std::make_unique<CXXStaticMethodRecord>(
-        USR, Name, Loc, std::move(Availability), Comment, Declaration,
-        SubHeading, Signature, Access, IsFromSystemHeader);
-  else
-    Record = std::make_unique<CXXInstanceMethodRecord>(
-        USR, Name, Loc, std::move(Availability), Comment, Declaration,
+CXXMethodRecord *APISet::addCXXInstanceMethod(
+    APIRecord *CXXClassRecord, StringRef Name, StringRef USR, PresumedLoc Loc,
+    AvailabilitySet Availability, const DocComment &Comment,
+    DeclarationFragments Declaration, DeclarationFragments SubHeading,
+    FunctionSignature Signature, AccessControl Access,
+    bool IsFromSystemHeader) {
+  CXXMethodRecord *Record =
+      addTopLevelRecord(USRBasedLookupTable, CXXInstanceMethods, USR, Name, Loc,
+                        std::move(Availability), Comment, Declaration,
                         SubHeading, Signature, Access, IsFromSystemHeader);
 
   Record->ParentInformation = APIRecord::HierarchyInformation(
       CXXClassRecord->USR, CXXClassRecord->Name, CXXClassRecord->getKind(),
       CXXClassRecord);
-  USRBasedLookupTable.insert({USR, Record.get()});
-  return CXXClassRecord->Methods.emplace_back(std::move(Record)).get();
+  return Record;
 }
 
-CXXMethodRecord *APISet::addCXXSpecialMethod(
-    CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
-    PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,
+CXXMethodRecord *APISet::addCXXStaticMethod(
+    APIRecord *CXXClassRecord, StringRef Name, StringRef USR, PresumedLoc Loc,
+    AvailabilitySet Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading,
-    FunctionSignature Signature, bool IsConstructor, AccessControl Access,
+    FunctionSignature Signature, AccessControl Access,
     bool IsFromSystemHeader) {
-  std::unique_ptr<CXXMethodRecord> Record;
-  if (IsConstructor)
-    Record = std::make_unique<CXXConstructorRecord>(
-        USR, Name, Loc, std::move(Availability), Comment, Declaration,
-        SubHeading, Signature, Access, IsFromSystemHeader);
-  else
-    Record = std::make_unique<CXXDestructorRecord>(
-        USR, Name, Loc, std::move(Availability), Comment, Declaration,
+  CXXMethodRecord *Record =
+      addTopLevelRecord(USRBasedLookupTable, CXXStaticMethods, USR, Name, Loc,
+                        std::move(Availability), Comment, Declaration,
                         SubHeading, Signature, Access, IsFromSystemHeader);
 
   Record->ParentInformation = APIRecord::HierarchyInformation(
       CXXClassRecord->USR, CXXClassRecord->Name, CXXClassRecord->getKind(),
       CXXClassRecord);
-  USRBasedLookupTable.insert({USR, Record.get()});
-  return CXXClassRecord->Methods.emplace_back(std::move(Record)).get();
+  return Record;
 }
 
 CXXMethodTemplateRecord *APISet::addCXXMethodTemplate(
     APIRecord *Parent, StringRef Name, StringRef USR, PresumedLoc Loc,
     AvailabilitySet Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading,
     FunctionSignature Signature, AccessControl Access, Template Template,
     bool IsFromSystemHeader) {

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 }
 
 void SymbolGraphSerializer::visitCXXClassRecord(const CXXClassRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  serializeMembers(Record, Record.Fields);
-  serializeMembers(Record, Record.Methods);
-
   for (const auto Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
 }
 
 void SymbolGraphSerializer::visitClassTemplateRecord(
     const ClassTemplateRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  serializeMembers(Record, Record.Fields);
-  serializeMembers(Record, Record.Methods);
-
   for (const auto Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
 }
 
 void SymbolGraphSerializer::visitClassTemplateSpecializationRecord(
     const ClassTemplateSpecializationRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  serializeMembers(Record, Record.Fields);
-  serializeMembers(Record, Record.Methods);
 
   for (const auto Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
 }
 
 void SymbolGraphSerializer::visitClassTemplatePartialSpecializationRecord(
     const ClassTemplatePartialSpecializationRecord &Record) {
   auto Class = serializeAPIRecord(Record);
   if (!Class)
     return;
 
   Symbols.emplace_back(std::move(*Class));
-  serializeMembers(Record, Record.Fields);
-  serializeMembers(Record, Record.Methods);
 
   for (const auto Base : Record.Bases)
     serializeRelationship(RelationshipKind::InheritsFrom, Record, Base);
 }
 
+void SymbolGraphSerializer::visitCXXInstanceMethodRecord(
+    const CXXInstanceMethodRecord &Record) {
+  auto InstanceMethod = serializeAPIRecord(Record);
+  if (!InstanceMethod)
+    return;
+
+  Symbols.emplace_back(std::move(*InstanceMethod));
+  serializeRelationship(RelationshipKind::MemberOf, Record,
+                        Record.ParentInformation.ParentRecord);
+}
+
+void SymbolGraphSerializer::visitCXXStaticMethodRecord(
+    const CXXStaticMethodRecord &Record) {
+  auto StaticMethod = serializeAPIRecord(Record);
+  if (!StaticMethod)
+    return;
+
+  Symbols.emplace_back(std::move(*StaticMethod));
+  serializeRelationship(RelationshipKind::MemberOf, Record,
+                        Record.ParentInformation.ParentRecord);
+}
+
 void SymbolGraphSerializer::visitMethodTemplateRecord(
     const CXXMethodTemplateRecord &Record) {
   if (!ShouldRecurse)
     // Ignore child symbols
     return;
   auto MethodTemplate = serializeAPIRecord(Record);
   if (!MethodTemplate)
     return;
void SymbolGraphSerializer::visitMethodTemplateSpecializationRecord(
   auto MethodTemplateSpecialization = serializeAPIRecord(Record);
   if (!MethodTemplateSpecialization)
     return;
   Symbols.emplace_back(std::move(*MethodTemplateSpecialization));
   serializeRelationship(RelationshipKind::MemberOf, Record,
                         Record.ParentInformation.ParentRecord);
 }
 
+void SymbolGraphSerializer::visitCXXFieldRecord(const CXXFieldRecord &Record) {
+  if (!ShouldRecurse)
+    return;
+  auto CXXField = serializeAPIRecord(Record);
+  if (!CXXField)
+    return;
+  Symbols.emplace_back(std::move(*CXXField));
+  serializeRelationship(RelationshipKind::MemberOf, Record,
+                        Record.ParentInformation.ParentRecord);
+}
+
 void SymbolGraphSerializer::visitCXXFieldTemplateRecord(
     const CXXFieldTemplateRecord &Record) {
   if (!ShouldRecurse)
     // Ignore child symbols
     return;
   auto CXXFieldTemplate = serializeAPIRecord(Record);
   if (!CXXFieldTemplate)
     return;

clang/test/ExtractAPI/constructor_destructor.cpp

"symbols": [
           }
         ]
       },
       "identifier": {
         "interfaceLanguage": "c++",
         "precise": "c:@S@Foo@F@Foo#"
       },
       "kind": {
-        "displayName": "Constructor",
+        "displayName": "Instance Method",
         "identifier": "c++.method"
       },
       "location": {
         "position": {
           "character": 3,
           "line": 2
         },
         "uri": "file://INPUT_DIR/input.h"
"symbols": [
           }
         ]
       },
       "identifier": {
         "interfaceLanguage": "c++",
         "precise": "c:@S@Foo@F@~Foo#"
       },
       "kind": {
-        "displayName": "Destructor",
+        "displayName": "Instance Method",
         "identifier": "c++.method"
       },
       "location": {
         "position": {
           "character": 3,
           "line": 3
         },
         "uri": "file://INPUT_DIR/input.h"

clang/test/ExtractAPI/methods.cpp

"relationships": [
     {
       "kind": "memberOf",
       "source": "c:@S@Foo@F@setLength#I#",
       "target": "c:@S@Foo",
       "targetFallback": "Foo"
     },
     {
       "kind": "memberOf",
-      "source": "c:@S@Foo@F@getFoo#S",
+      "source": "c:@S@Foo@F@getBar#1",
       "target": "c:@S@Foo",
       "targetFallback": "Foo"
     },
     {
       "kind": "memberOf",
-      "source": "c:@S@Foo@F@getBar#1",
+      "source": "c:@S@Foo@F@getFoo#S",
       "target": "c:@S@Foo",
       "targetFallback": "Foo"
     }
   ],
   "symbols": [
     {
       "accessLevel": "public",
       "declarationFragments": [
"symbols": [
         "title": "setLength"
       },
       "pathComponents": [
         "Foo",
         "setLength"
       ]
     },
     {
-      "accessLevel": "public",
+      "accessLevel": "protected",
       "declarationFragments": [
         {
           "kind": "keyword",
-          "spelling": "static"
+          "spelling": "constexpr"
         },
         {
           "kind": "text",
           "spelling": " "
         },
         {
           "kind": "typeIdentifier",
-          "preciseIdentifier": "c:d",
-          "spelling": "double"
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
         },
         {
           "kind": "text",
           "spelling": " "
         },
         {
           "kind": "identifier",
-          "spelling": "getFoo"
+          "spelling": "getBar"
         },
         {
           "kind": "text",
-          "spelling": "();"
+          "spelling": "() "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "const"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
         }
       ],
       "functionSignature": {
         "returns": [
           {
             "kind": "typeIdentifier",
-            "preciseIdentifier": "c:d",
-            "spelling": "double"
+            "preciseIdentifier": "c:I",
+            "spelling": "int"
           }
         ]
       },
       "identifier": {
         "interfaceLanguage": "c++",
-        "precise": "c:@S@Foo@F@getFoo#S"
+        "precise": "c:@S@Foo@F@getBar#1"
       },
       "kind": {
-        "displayName": "Static Method",
-        "identifier": "c++.type.method"
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
       },
       "location": {
         "position": {
           "character": 17,
-          "line": 7
+          "line": 10
         },
         "uri": "file://INPUT_DIR/input.h"
       },
       "names": {
         "navigator": [
           {
             "kind": "identifier",
-            "spelling": "getFoo"
+            "spelling": "getBar"
           }
         ],
         "subHeading": [
           {
             "kind": "identifier",
-            "spelling": "getFoo"
+            "spelling": "getBar"
           }
         ],
-        "title": "getFoo"
+        "title": "getBar"
       },
       "pathComponents": [
         "Foo",
-        "getFoo"
+        "getBar"
       ]
     },
     {
-      "accessLevel": "protected",
+      "accessLevel": "public",
       "declarationFragments": [
         {
           "kind": "keyword",
-          "spelling": "constexpr"
+          "spelling": "static"
         },
         {
           "kind": "text",
           "spelling": " "
         },
         {
           "kind": "typeIdentifier",
-          "preciseIdentifier": "c:I",
-          "spelling": "int"
+          "preciseIdentifier": "c:d",
+          "spelling": "double"
         },
         {
           "kind": "text",
           "spelling": " "
         },
         {
           "kind": "identifier",
-          "spelling": "getBar"
-        },
-        {
-          "kind": "text",
-          "spelling": "() "
-        },
-        {
-          "kind": "keyword",
-          "spelling": "const"
+          "spelling": "getFoo"
         },
         {
           "kind": "text",
-          "spelling": ";"
+          "spelling": "();"
         }
       ],
       "functionSignature": {
         "returns": [
           {
             "kind": "typeIdentifier",
-            "preciseIdentifier": "c:I",
-            "spelling": "int"
+            "preciseIdentifier": "c:d",
+            "spelling": "double"
           }
         ]
       },
       "identifier": {
         "interfaceLanguage": "c++",
-        "precise": "c:@S@Foo@F@getBar#1"
+        "precise": "c:@S@Foo@F@getFoo#S"
       },
       "kind": {
-        "displayName": "Instance Method",
-        "identifier": "c++.method"
+        "displayName": "Static Method",
+        "identifier": "c++.type.method"
       },
       "location": {
         "position": {
           "character": 17,
-          "line": 10
+          "line": 7
         },
         "uri": "file://INPUT_DIR/input.h"
       },
       "names": {
         "navigator": [
           {
             "kind": "identifier",
-            "spelling": "getBar"
+            "spelling": "getFoo"
           }
         ],
         "subHeading": [
           {
             "kind": "identifier",
-            "spelling": "getBar"
+            "spelling": "getFoo"
           }
         ],
-        "title": "getBar"
+        "title": "getFoo"
       },
       "pathComponents": [
         "Foo",
-        "getBar"
+        "getFoo"
       ]
     }
   ]
 }