[clang][ExtractAPI] Add support for C++ classes

[evelez7]

Summary

Add ExtractAPI support C++ classes, fields, methods, and various qualifiers and specifiers

[evelez7]

Add access control serialization

[evelez7]

Do not include return types for constructors/destructors

[evelez7]

Fix duplicate visitation of CXXRecordDecls by overloading WalkUpFromCXXRecordDecl

[evelez7]

Add conversion function and overloaded operator support

[dang]

Starting to come together nicely, but I think now would be a good time to write some tests. I am particularly interested in more complex situations like inheritance hierarchies.

clang/include/clang/ExtractAPI/API.h

25

Inste

637

Not sure this is correct, the semantic relationship is that structs and unions can be classes. This expresses that all struct records and unions are CXXClassRecords. It would be best to keep these entirely separate as classof is used by the type casting functions, e.g. llvm::dynamic_cast and we certainly don't want arbitrary struct or union record to be cast-able to CXXClassRecord.

776

mega nit: I suggest grouping together the has_function_signature trait and the has_access trait separately, i.e. moving the empty line from 770 to between 772 and 773

clang/include/clang/ExtractAPI/DeclarationFragments.h

185

Should this be API.h?

196

Instead of storing a reference to the string here, it might make sense to store the string itself, I am worried that for future usages in libclang the string references would go stale.

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

319–320

Is it to short circuit to only call VisitRecordDecl if so I think that it should call getDerivedExtractAPIVisitor().VisitRecordDecl

401

Is there a way of only looking at public bases here? Non-public inheritance is not part of the API surface of the class.

clang/lib/ExtractAPI/API.cpp

19

AccessControl should move into API.h so we don't need to pull in DeclarationFragments.h

44

This just pollutes the git history, would be best to remove this.

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

607

We still need all symbols to have an "accessLevel" specifier. Maybe the false_type overload of serializeAccessMixin could make "public" the default.

[evelez7]

Address some review feedback

Remove RK_Struct, RK_Union from CXXClassRecord::classof, use std::string for AccessControl, style and remove unused imports

[evelez7]

Add C++ class tests, fix exception spec fragments

• Add tests for single and multiple inheritance, class methods, and functions with noexcept.
• Exception spec fragments had a space included in it, moved it to separate fragment.

[evelez7]

There aren't any variables or fields in the tests currently, waiting on D154038 because of no semicolons in their fragments.

clang/lib/ExtractAPI/API.cpp

19

This include doesn't need to be here, clangd auto-included it. Using FunctionSignature would've explicitly included it in the first place. DeclarationFragments.h is already included in API.h.

I was following FunctionSignature as far as where to declare and define. Moving AccessControl would mean including API.h in DeclarationFragments.h to allow DeclarationFragmentsBuilder::getAccessControl.

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

607

This is done on line 534. "public" is serialized if the returned optional is empty.

[dang]

Looking pretty good, if you can address the last few bits of feedback I am happy to merge this.

clang/include/clang/ExtractAPI/API.h

770

Does CXXInstanceMethodRecord need one of these as well?

clang/include/clang/ExtractAPI/DeclarationFragments.h

25

Are these necessary?

187

For ergonomics would it make more sense to have a constructor that takes the string in directly and moves it to Access? I don't think there are any situation where you want to change the access string after the fact?

246

I assume the implementation of this moved because it was needed for C++ methods? Can you update the comment and maybe move the implementation to the bottom of the .h file?

clang/lib/ExtractAPI/DeclarationFragments.cpp

617

Please address this, it's pretty important imo.

clang/test/ExtractAPI/methods.cpp

14

I think these are redundant since you have // expected-no-diagnostics below and pass `--verify` to cc1.

[evelez7]

Address review feedback, add tests, and small refactors.

• Add tests for destructors, constructors, and conversion methods.
• Remove redundant check-nots in existing tests.
• Properly record destructor names.
• Add explicit qualifier to conversions.
• Remove unused code from getFragmentsForSpecialCXXMethod.
• Use appendSpace isntead of literals in keyword fragments.
• Initialize AccessControl with access string instead of using setter.

clang/include/clang/ExtractAPI/API.h

770

CXXInstanceMethodRecord inherits from CXXMethodRecord which holds the signature for all methods.

[evelez7]

Add test for overloaded operator.

[dang]

LGTM

[haowei]

Hi, we are seeing a test error on Clang :: ExtractAPI/constructor_destructor.cpp after this patch was landed. Error message:

Script:
--
: 'RUN: at line 1';   rm -rf /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp
: 'RUN: at line 2';   split-file /b/s/w/ir/x/w/llvm-llvm-project/clang/test/ExtractAPI/constructor_destructor.cpp /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp
: 'RUN: at line 3';   sed -e "s@INPUT_DIR@/b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp@g"  /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/reference.output.json.in >> /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/reference.output.json
: 'RUN: at line 5';   /b/s/w/ir/x/w/llvm_build/bin/clang++ -extract-api -target arm64-apple-macosx -x c++-header  /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/input.h -o /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/output.json -Xclang -verify
: 'RUN: at line 9';   sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g"  /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/output.json >> /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/output-normalized.json
: 'RUN: at line 11';   diff /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/reference.output.json /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/output-normalized.json
--
Exit Code: 1

Command Output (stderr):
--
clang++: llvm/include/llvm/Support/JSON.h:317: llvm::json::Value::Value(std::string): Assertion `false && "Invalid UTF-8 in value used as JSON"' failed.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /b/s/w/ir/x/w/llvm_build/bin/clang++ -extract-api -target arm64-apple-macosx -x c++-header /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/input.h -o /b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/constructor_destructor.cpp.tmp/output.json -Xclang -verify
#0 0x000055a2ec85c458 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/b/s/w/ir/x/w/llvm_build/bin/clang+++0x83e5458)
clang++: error: clang frontend command failed with exit code 134 (use -v to see invocation)
Fuchsia clang version 18.0.0 (https://llvm.googlesource.com/llvm-project dad9de0ae5360b18c890985d212bec266bf8c122)
Target: arm64-apple-macosx
Thread model: posix
InstalledDir: /b/s/w/ir/x/w/llvm_build/bin
clang++: note: diagnostic msg: 
********************

PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:
Preprocessed source(s) and associated run script(s) are located at:
clang++: note: diagnostic msg: /b/s/w/ir/x/t/lit-tmp-0iloyqe3/input-5086dc.hh
clang++: note: diagnostic msg: /b/s/w/ir/x/t/lit-tmp-0iloyqe3/input-5086dc.sh
clang++: note: diagnostic msg: 

********************

--

Link to the builder: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8773854265208228753/overview

It looks like it triggers an assertion error in llvm's JSON library. Could you take a look please? If it takes some time to fix, could you revert your change please? Thanks.

[evelez7]

This comment was removed by evelez7.

[haowei]

Thanks for reverting. I wasn't doing any changes to this when you were asking though, but looking at build log, it looks like the assertion error disappeared after f4de606ef271fe362f03d30c53a850f9877ec238 was landed.

[evelez7]

@haowei Thank you for letting me know! That patch does seem to fix it, unfortunately it didn't fail on my end. Thanks again.

[haowei]

FYI, this patch fails the Windows bots in a different way. (you can see the error triggered in the pre-merge build in https://buildkite.com/llvm-project/premerge-checks/builds/161603#018909c4-fe90-4de6-91a3-d251dc5ada8f)

The error message from our builders are:

Script:
--
: 'RUN: at line 1';   rm -rf C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp
: 'RUN: at line 2';   split-file C:\b\s\w\ir\x\w\llvm-llvm-project\clang\test\ExtractAPI\class.cpp C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp
: 'RUN: at line 3';   sed -e "s@INPUT_DIR@C:/b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/class.cpp.tmp@g"  C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/reference.output.json.in >> C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/reference.output.json
: 'RUN: at line 5';   c:\b\s\w\ir\x\w\llvm_build\bin\clang.exe++ -extract-api -target arm64-apple-macosx -x c++-header  C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/input.h -o C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/output.json -Xclang -verify
: 'RUN: at line 9';   sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g"  C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/output.json >> C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/output-normalized.json
: 'RUN: at line 11';   diff C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/reference.output.json C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/output-normalized.json
--
Exit Code: 127

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "rm" "-rf" "C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp"
$ ":" "RUN: at line 2"
$ "split-file" "C:\b\s\w\ir\x\w\llvm-llvm-project\clang\test\ExtractAPI\class.cpp" "C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp"
$ ":" "RUN: at line 3"
$ "sed" "-e" "s@INPUT_DIR@C:/b/s/w/ir/x/w/llvm_build/tools/clang/test/ExtractAPI/Output/class.cpp.tmp@g" "C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/reference.output.json.in"
$ ":" "RUN: at line 5"
$ "c:\b\s\w\ir\x\w\llvm_build\bin\clang.exe++" "-extract-api" "-target" "arm64-apple-macosx" "-x" "c++-header" "C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/input.h" "-o" "C:\b\s\w\ir\x\w\llvm_build\tools\clang\test\ExtractAPI\Output\class.cpp.tmp/output.json" "-Xclang" "-verify"
# command stderr:
'c:\\b\\s\\w\\ir\\x\\w\\llvm_build\\bin\\clang.exe++': command not found
error: command failed with exit status: 127

--

Link to the failed task: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-windows-x64/b8773853314698659521/overview

%clang++ is probably not the correct way to invoke clang++ as it was replaced as clang.exe++ on Windows

[evelez7]

Reintroduce fix from f4de606ef271 and use clang frontend for C++ tests.

clang/include/clang/ExtractAPI/API.h

 
 #ifndef LLVM_CLANG_EXTRACTAPI_API_H
 #define LLVM_CLANG_EXTRACTAPI_API_H
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/ExtractAPI/AvailabilityInfo.h"
 #include "clang/ExtractAPI/DeclarationFragments.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/TargetParser/Triple.h"
 #include <memory>
struct APIRecord {
   enum RecordKind {
     RK_Unknown,
     RK_GlobalFunction,
     RK_GlobalVariable,
     RK_EnumConstant,
     RK_Enum,
     RK_StructField,
     RK_Struct,
+    RK_Union,
+    RK_StaticField,
+    RK_CXXField,
+    RK_CXXClass,
+    RK_CXXStaticMethod,
+    RK_CXXInstanceMethod,
+    RK_CXXConstructorMethod,
+    RK_CXXDestructorMethod,
     RK_ObjCInstanceProperty,
     RK_ObjCClassProperty,
     RK_ObjCIvar,
     RK_ObjCClassMethod,
     RK_ObjCInstanceMethod,
     RK_ObjCInterface,
     RK_ObjCCategory,
     RK_ObjCProtocol,
struct StructRecord : APIRecord {
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_Struct;
   }
 
 private:
   virtual void anchor();
 };
 
+struct CXXFieldRecord : APIRecord {
+  AccessControl Access;
+
+  CXXFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                 AvailabilitySet Availabilities, const DocComment &Comment,
+                 DeclarationFragments Declaration,
+                 DeclarationFragments SubHeading, AccessControl Access,
+                 bool IsFromSystemHeader)
+      : APIRecord(RK_CXXField, USR, Name, Loc, std::move(Availabilities),
+                  LinkageInfo::none(), Comment, Declaration, SubHeading,
+                  IsFromSystemHeader),
+        Access(Access) {}
+
+  CXXFieldRecord(RecordKind Kind, StringRef USR, StringRef Name,
+                 PresumedLoc Loc, AvailabilitySet Availabilities,
+                 const DocComment &Comment, DeclarationFragments Declaration,
+                 DeclarationFragments SubHeading, AccessControl Access,
+                 bool IsFromSystemHeader)
+      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities),
+                  LinkageInfo::none(), Comment, Declaration, SubHeading,
+                  IsFromSystemHeader),
+        Access(Access) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_CXXField;
+  }
+
+private:
+  virtual void anchor();
+};
+
+struct CXXMethodRecord : APIRecord {
+  FunctionSignature Signature;
+  AccessControl Access;
+
+  CXXMethodRecord() = delete;
+
+  CXXMethodRecord(RecordKind Kind, StringRef USR, StringRef Name,
+                  PresumedLoc Loc, AvailabilitySet Availabilities,
+                  const DocComment &Comment, DeclarationFragments Declaration,
+                  DeclarationFragments SubHeading, FunctionSignature Signature,
+                  AccessControl Access, bool IsFromSystemHeader)
+      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities),
+                  LinkageInfo::none(), Comment, Declaration, SubHeading,
+                  IsFromSystemHeader),
+        Signature(Signature), Access(Access) {}
+
+  virtual ~CXXMethodRecord() = 0;
+};
+
+struct CXXConstructorRecord : CXXMethodRecord {
+  CXXConstructorRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                       AvailabilitySet Availabilities,
+                       const DocComment &Comment,
+                       DeclarationFragments Declaration,
+                       DeclarationFragments SubHeading,
+                       FunctionSignature Signature, AccessControl Access,
+                       bool IsFromSystemHeader)
+      : CXXMethodRecord(RK_CXXConstructorMethod, USR, Name, Loc,
+                        std::move(Availabilities), Comment, Declaration,
+                        SubHeading, Signature, Access, IsFromSystemHeader) {}
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_CXXConstructorMethod;
+  }
+
+private:
+  virtual void anchor();
+};
+
+struct CXXDestructorRecord : CXXMethodRecord {
+  CXXDestructorRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                      AvailabilitySet Availabilities, const DocComment &Comment,
+                      DeclarationFragments Declaration,
+                      DeclarationFragments SubHeading,
+                      FunctionSignature Signature, AccessControl Access,
+                      bool IsFromSystemHeader)
+      : CXXMethodRecord(RK_CXXDestructorMethod, USR, Name, Loc,
+                        std::move(Availabilities), Comment, Declaration,
+                        SubHeading, Signature, Access, IsFromSystemHeader) {}
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_CXXDestructorMethod;
+  }
+
+private:
+  virtual void anchor();
+};
+
+struct CXXStaticMethodRecord : CXXMethodRecord {
+  CXXStaticMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                        AvailabilitySet Availabilities,
+                        const DocComment &Comment,
+                        DeclarationFragments Declaration,
+                        DeclarationFragments SubHeading,
+                        FunctionSignature Signature, AccessControl Access,
+                        bool IsFromSystemHeader)
+      : CXXMethodRecord(RK_CXXStaticMethod, USR, Name, Loc,
+                        std::move(Availabilities), Comment, Declaration,
+                        SubHeading, Signature, Access, IsFromSystemHeader) {}
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_CXXStaticMethod;
+  }
+
+private:
+  virtual void anchor();
+};
+
+struct CXXInstanceMethodRecord : CXXMethodRecord {
+  CXXInstanceMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                          AvailabilitySet Availabilities,
+                          const DocComment &Comment,
+                          DeclarationFragments Declaration,
+                          DeclarationFragments SubHeading,
+                          FunctionSignature Signature, AccessControl Access,
+                          bool IsFromSystemHeader)
+      : CXXMethodRecord(RK_CXXInstanceMethod, USR, Name, Loc,
+                        std::move(Availabilities), Comment, Declaration,
+                        SubHeading, Signature, Access, IsFromSystemHeader) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_CXXInstanceMethod;
+  }
+
+private:
+  virtual void anchor();
+};
+
 /// This holds information associated with Objective-C properties.
 struct ObjCPropertyRecord : APIRecord {
   /// The attributes associated with an Objective-C property.
   enum AttributeKind : unsigned {
     NoAttr = 0,
     ReadOnly = 1,
     Dynamic = 1 << 2,
   };
SymbolReference(const APIRecord &Record)
       : Name(Record.Name), USR(Record.USR) {}
 
   /// Determine if this SymbolReference is empty.
   ///
   /// \returns true if and only if all \c Name, \c USR, and \c Source is empty.
   bool empty() const { return Name.empty() && USR.empty() && Source.empty(); }
 };
 
+struct StaticFieldRecord : CXXFieldRecord {
+  SymbolReference Context;
+
+  StaticFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                    AvailabilitySet Availabilities, LinkageInfo Linkage,
+                    const DocComment &Comment, DeclarationFragments Declaration,
+                    DeclarationFragments SubHeading, SymbolReference Context,
+                    AccessControl Access, bool IsFromSystemHeader)
+      : CXXFieldRecord(RK_StaticField, USR, Name, Loc,
+                       std::move(Availabilities), Comment, Declaration,
+                       SubHeading, Access, IsFromSystemHeader),
+        Context(Context) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_StaticField;
+  }
+};
+
 /// The base representation of an Objective-C container record. Holds common
 /// information associated with Objective-C containers.
 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 USR, StringRef Name,
                       PresumedLoc Loc, AvailabilitySet Availabilities,
                       LinkageInfo Linkage, const DocComment &Comment,
                       DeclarationFragments Declaration,
                       DeclarationFragments SubHeading, bool IsFromSystemHeader)
       : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities), Linkage,
                   Comment, Declaration, SubHeading, IsFromSystemHeader) {}
 
   virtual ~ObjCContainerRecord() = 0;
 };
 
+struct CXXClassRecord : APIRecord {
+  SmallVector<std::unique_ptr<CXXFieldRecord>> Fields;
+  SmallVector<std::unique_ptr<CXXMethodRecord>> Methods;
+  SmallVector<SymbolReference> Bases;
+
+  CXXClassRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                 AvailabilitySet Availabilities, const DocComment &Comment,
+                 DeclarationFragments Declaration,
+                 DeclarationFragments SubHeading, RecordKind Kind,
+                 bool IsFromSystemHeader)
+      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities),
+                  LinkageInfo::none(), Comment, Declaration, SubHeading,
+                  IsFromSystemHeader) {}
+
+  static bool classof(const APIRecord *Record) {
+    return (Record->getKind() == RK_CXXClass);
+  }
+
+private:
+  virtual void anchor();
+};
+
 /// This holds information associated with Objective-C categories.
 struct ObjCCategoryRecord : ObjCContainerRecord {
   SymbolReference Interface;
 
   ObjCCategoryRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      AvailabilitySet Availabilities, const DocComment &Comment,
                      DeclarationFragments Declaration,
                      DeclarationFragments SubHeading, SymbolReference Interface,

 struct has_function_signature<GlobalFunctionRecord> : public std::true_type {};
 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 {};
+
+template <typename RecordTy> struct has_access : public std::false_type {};
+template <> struct has_access<CXXMethodRecord> : public std::true_type {};
+template <> struct has_access<CXXFieldRecord> : public std::true_type {};
 
 /// APISet holds the set of API records collected from given inputs.
 class APISet {
 public:
   /// Create and add a global variable record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
public:
   /// to generate the USR for \c D and keep it alive in APISet.
   StructRecord *addStruct(StringRef Name, StringRef USR, PresumedLoc Loc,
                           AvailabilitySet Availability,
                           const DocComment &Comment,
                           DeclarationFragments Declaration,
                           DeclarationFragments SubHeading,
                           bool IsFromSystemHeader);
 
+  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,
+                              StringRef USR, PresumedLoc Loc,
+                              AvailabilitySet Availabilities,
+                              const DocComment &Comment,
+                              DeclarationFragments Declaration,
+                              DeclarationFragments SubHeading,
+                              AccessControl Access, bool IsFromSystemHeader);
+
+  CXXClassRecord *
+  addCXXClass(StringRef Name, StringRef USR, PresumedLoc Loc,
+              AvailabilitySet Availability, const DocComment &Comment,
+              DeclarationFragments Declaration, DeclarationFragments SubHeading,
+              APIRecord::RecordKind Kind, 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 *addCXXSpecialMethod(
+      CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
+      PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,
+      DeclarationFragments Declaration, DeclarationFragments SubHeading,
+      FunctionSignature Signature, bool IsConstructor, AccessControl Access,
+      bool IsFromSystemHeader);
+
   /// Create and add an Objective-C category record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
   ObjCCategoryRecord *
   addObjCCategory(StringRef Name, StringRef USR, PresumedLoc Loc,
public:
   Language getLanguage() const { return Lang; }
 
   const RecordMap<GlobalFunctionRecord> &getGlobalFunctions() const {
     return GlobalFunctions;
   }
   const RecordMap<GlobalVariableRecord> &getGlobalVariables() const {
     return GlobalVariables;
   }
+  const RecordMap<StaticFieldRecord> &getStaticFields() const {
+    return StaticFields;
+  }
   const RecordMap<EnumRecord> &getEnums() const { return Enums; }
   const RecordMap<StructRecord> &getStructs() const { return Structs; }
+  const RecordMap<CXXClassRecord> &getCXXClasses() const { return CXXClasses; }
   const RecordMap<ObjCCategoryRecord> &getObjCCategories() const {
     return ObjCCategories;
   }
   const RecordMap<ObjCInterfaceRecord> &getObjCInterfaces() const {
     return ObjCInterfaces;
   }
   const RecordMap<ObjCProtocolRecord> &getObjCProtocols() const {
     return ObjCProtocols;
private:
   llvm::BumpPtrAllocator StringAllocator;
 
   const llvm::Triple Target;
   const Language Lang;
 
   llvm::DenseMap<StringRef, APIRecord *> USRBasedLookupTable;
   RecordMap<GlobalFunctionRecord> GlobalFunctions;
   RecordMap<GlobalVariableRecord> GlobalVariables;
+  RecordMap<StaticFieldRecord> StaticFields;
   RecordMap<EnumRecord> Enums;
   RecordMap<StructRecord> Structs;
+  RecordMap<CXXClassRecord> CXXClasses;
   RecordMap<ObjCCategoryRecord> ObjCCategories;
   RecordMap<ObjCInterfaceRecord> ObjCInterfaces;
   RecordMap<ObjCProtocolRecord> ObjCProtocols;
   RecordMap<MacroDefinitionRecord> Macros;
   RecordMap<TypedefRecord> Typedefs;
 
 public:
   const std::string ProductName;
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_API_H

clang/include/clang/ExtractAPI/DeclarationFragments.h

 
 #ifndef LLVM_CLANG_EXTRACTAPI_DECLARATION_FRAGMENTS_H
 #define LLVM_CLANG_EXTRACTAPI_DECLARATION_FRAGMENTS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Lex/MacroInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 namespace clang {
 namespace extractapi {
 
 /// DeclarationFragments is a vector of tagged important parts of a symbol's
 /// declaration.
public:
   DeclarationFragments &appendSpace();
 
   /// Get the string description of a FragmentKind \p Kind.
   static StringRef getFragmentKindString(FragmentKind Kind);
 
   /// Get the corresponding FragmentKind from string \p S.
   static FragmentKind parseFragmentKindFromString(StringRef S);
 
+  static DeclarationFragments
+  getExceptionSpecificationString(ExceptionSpecificationType ExceptionSpec);
+
+  static DeclarationFragments getStructureTypeFragment(const RecordDecl *Decl);
+
 private:
   std::vector<Fragment> Fragments;
 };
 
+class AccessControl {
+public:
+  AccessControl(std::string Access) : Access(Access) {}
+
+  const std::string &getAccess() const { return Access; }
+
+  bool empty() const { return Access.empty(); }
+
+private:
+  std::string Access;
+};
+
 /// Store function signature information with DeclarationFragments of the
 /// return type and parameters.
 class FunctionSignature {
 public:
   FunctionSignature() = default;
 
   /// Parameter holds the name and DeclarationFragments of a single parameter.
   struct Parameter {

 private:
   std::vector<Parameter> Parameters;
   DeclarationFragments ReturnType;
 };
 
 /// A factory class to build DeclarationFragments for different kinds of Decl.
 class DeclarationFragmentsBuilder {
 public:
+  /// Build FunctionSignature for a function-like declaration \c FunctionT like
+  /// FunctionDecl, ObjCMethodDecl, or CXXMethodDecl.
+  ///
+  /// The logic and implementation of building a signature for a FunctionDecl,
+  /// CXXMethodDecl, and ObjCMethodDecl are exactly the same, but they do not
+  /// share a common base. This template helps reuse the code.
+  template <typename FunctionT>
+  static FunctionSignature getFunctionSignature(const FunctionT *Function);
+
+  static AccessControl getAccessControl(const Decl *Decl) {
+    switch (Decl->getAccess()) {
+    case AS_public:
+      return AccessControl("public");
+    case AS_private:
+      return AccessControl("private");
+    case AS_protected:
+      return AccessControl("protected");
+    case AS_none:
+      return AccessControl("none");
+    }
+    llvm_unreachable("Unhandled access control");
+  }
+
   /// Build DeclarationFragments for a variable declaration VarDecl.
   static DeclarationFragments getFragmentsForVar(const VarDecl *);
 
   /// Build DeclarationFragments for a function declaration FunctionDecl.
   static DeclarationFragments getFragmentsForFunction(const FunctionDecl *);
 
   /// Build DeclarationFragments for an enum constant declaration
   /// EnumConstantDecl.
   static DeclarationFragments
   getFragmentsForEnumConstant(const EnumConstantDecl *);
 
   /// Build DeclarationFragments for an enum declaration EnumDecl.
   static DeclarationFragments getFragmentsForEnum(const EnumDecl *);
 
   /// Build DeclarationFragments for a field declaration FieldDecl.
   static DeclarationFragments getFragmentsForField(const FieldDecl *);
 
   /// Build DeclarationFragments for a struct record declaration RecordDecl.
   static DeclarationFragments getFragmentsForStruct(const RecordDecl *);
 
+  static DeclarationFragments getFragmentsForCXXClass(const CXXRecordDecl *);
+
+  static DeclarationFragments
+  getFragmentsForSpecialCXXMethod(const CXXMethodDecl *);
+
+  static DeclarationFragments getFragmentsForCXXMethod(const CXXMethodDecl *);
+
+  static DeclarationFragments
+  getFragmentsForConversionFunction(const CXXConversionDecl *);
+
+  static DeclarationFragments
+  getFragmentsForOverloadedOperator(const CXXMethodDecl *);
+
   /// Build DeclarationFragments for an Objective-C category declaration
   /// ObjCCategoryDecl.
   static DeclarationFragments
   getFragmentsForObjCCategory(const ObjCCategoryDecl *);
 
   /// Build DeclarationFragments for an Objective-C interface declaration
   /// ObjCInterfaceDecl.
   static DeclarationFragments
public:
   static DeclarationFragments getSubHeading(const NamedDecl *);
 
   /// Build sub-heading fragments for an Objective-C method.
   static DeclarationFragments getSubHeading(const ObjCMethodDecl *);
 
   /// Build a sub-heading for macro \p Name.
   static DeclarationFragments getSubHeadingForMacro(StringRef Name);
 
-  /// Build FunctionSignature for a function-like declaration \c FunctionT like
-  /// FunctionDecl or ObjCMethodDecl.
-  ///
-  /// The logic and implementation of building a signature for a FunctionDecl
-  /// and an ObjCMethodDecl are exactly the same, but they do not share a common
-  /// base. This template helps reuse the code.
-  template <typename FunctionT>
-  static FunctionSignature getFunctionSignature(const FunctionT *);
-
 private:
   DeclarationFragmentsBuilder() = delete;
 
   /// Build DeclarationFragments for a QualType.
   static DeclarationFragments getFragmentsForType(const QualType, ASTContext &,
                                                   DeclarationFragments &);
 
   /// Build DeclarationFragments for a Type.
   static DeclarationFragments getFragmentsForType(const Type *, ASTContext &,
                                                   DeclarationFragments &);
 
   /// Build DeclarationFragments for a NestedNameSpecifier.
   static DeclarationFragments getFragmentsForNNS(const NestedNameSpecifier *,
                                                  ASTContext &,
                                                  DeclarationFragments &);
 
   /// Build DeclarationFragments for Qualifiers.
   static DeclarationFragments getFragmentsForQualifiers(const Qualifiers quals);
 
   /// Build DeclarationFragments for a parameter variable declaration
   /// ParmVarDecl.
   static DeclarationFragments getFragmentsForParam(const ParmVarDecl *);
 };
 
+template <typename FunctionT>
+FunctionSignature
+DeclarationFragmentsBuilder::getFunctionSignature(const FunctionT *Function) {
+  FunctionSignature Signature;
+
+  DeclarationFragments ReturnType, After;
+  ReturnType
+      .append(getFragmentsForType(Function->getReturnType(),
+                                  Function->getASTContext(), After))
+      .append(std::move(After));
+  Signature.setReturnType(ReturnType);
+
+  for (const auto *Param : Function->parameters())
+    Signature.addParameter(Param->getName(), getFragmentsForParam(Param));
+
+  return Signature;
+}
+
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_DECLARATION_FRAGMENTS_H

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

 //===- ExtractAPI/ExtractAPIVisitor.h ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines the ExtractAPVisitor AST visitation interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_EXTRACTAPI_EXTRACT_API_VISITOR_H
 #define LLVM_CLANG_EXTRACTAPI_EXTRACT_API_VISITOR_H
 
+#include "clang/AST/DeclCXX.h"
+#include "clang/Basic/OperatorKinds.h"
+#include "clang/Basic/Specifiers.h"
+#include "clang/ExtractAPI/DeclarationFragments.h"
 #include "llvm/ADT/FunctionExtras.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ParentMapContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/ExtractAPI/API.h"
 #include "clang/ExtractAPI/TypedefUnderlyingTypeResolver.h"
public:
   const APISet &getAPI() const { return API; }
 
   bool VisitVarDecl(const VarDecl *Decl);
 
   bool VisitFunctionDecl(const FunctionDecl *Decl);
 
   bool VisitEnumDecl(const EnumDecl *Decl);
 
+  bool WalkUpFromRecordDecl(const RecordDecl *Decl);
+
+  bool WalkUpFromCXXRecordDecl(const CXXRecordDecl *Decl);
+
   bool VisitRecordDecl(const RecordDecl *Decl);
 
+  bool VisitCXXRecordDecl(const CXXRecordDecl *Decl);
+
   bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *Decl);
 
   bool VisitObjCProtocolDecl(const ObjCProtocolDecl *Decl);
 
   bool VisitTypedefNameDecl(const TypedefNameDecl *Decl);
 
   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *Decl);
 
   bool shouldDeclBeIncluded(const Decl *Decl) const;
 
   const RawComment *fetchRawCommentForDecl(const Decl *Decl) const;
 
 protected:
   /// Collect API information for the enum constants and associate with the
   /// parent enum.
   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);
 

 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitVarDecl(const VarDecl *Decl) {
   // skip function parameters.
   if (isa<ParmVarDecl>(Decl))
     return true;
 
-  // Skip non-global variables in records (struct/union/class).
-  if (Decl->getDeclContext()->isRecord())
+  // Skip non-global variables in records (struct/union/class) but not static
+  // members.
+  if (Decl->getDeclContext()->isRecord() && !Decl->isStaticDataMember())
     return true;
 
   // Skip local variables inside function or method.
   if (!Decl->isDefinedOutsideFunctionOrMethod())
     return true;
 
   // If this is a template but not specialization or instantiation, skip.
   if (Decl->getASTContext().getTemplateOrSpecializationInfo(Decl) &&
Comment = RawComment->getFormattedLines(Context.getSourceManager(),
                                             Context.getDiagnostics());
 
   // Build declaration fragments and sub-heading for the variable.
   DeclarationFragments Declaration =
       DeclarationFragmentsBuilder::getFragmentsForVar(Decl);
   DeclarationFragments SubHeading =
       DeclarationFragmentsBuilder::getSubHeading(Decl);
 
+  if (Decl->isStaticDataMember()) {
+    SymbolReference Context;
+    auto Record = dyn_cast<RecordDecl>(Decl->getDeclContext());
+    Context.Name = Record->getName();
+    Context.USR = API.recordUSR(Record);
+    auto Access = DeclarationFragmentsBuilder::getAccessControl(Decl);
+    API.addStaticField(Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
+                       Declaration, SubHeading, Context, Access,
+                       isInSystemHeader(Decl));
+  } else
     // Add the global variable record to the API set.
     API.addGlobalVar(Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
                      Declaration, SubHeading, isInSystemHeader(Decl));
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitFunctionDecl(
     const FunctionDecl *Decl) {
   if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     // Skip member function in class templates.
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>::VisitRecordDecl(const RecordDecl *Decl) {
-  // Skip C++ structs/classes/unions
-  // TODO: support C++ records
-  if (isa<CXXRecordDecl>(Decl))
-    return true;
+bool ExtractAPIVisitorBase<Derived>::WalkUpFromRecordDecl(
+    const RecordDecl *Decl) {
+  getDerivedExtractAPIVisitor().VisitRecordDecl(Decl);
+}
 
-  if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
-    return true;
+template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::WalkUpFromCXXRecordDecl(
+    const CXXRecordDecl *Decl) {
+  getDerivedExtractAPIVisitor().VisitCXXRecordDecl(Decl);
+}
 
+template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::VisitRecordDecl(const RecordDecl *Decl) {
+  if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
+    return true;
   // Collect symbol information.
   StringRef Name = Decl->getName();
   if (Name.empty())
     Name = getTypedefName(Decl);
   if (Name.empty())
     return true;
 
   StringRef USR = API.recordUSR(Decl);
bool ExtractAPIVisitorBase<Derived>::VisitRecordDecl(const RecordDecl *Decl) {
   // Now collect information about the fields in this struct.
   getDerivedExtractAPIVisitor().recordStructFields(StructRecord,
                                                    Decl->fields());
 
   return true;
 }
 
 template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::VisitCXXRecordDecl(
+    const CXXRecordDecl *Decl) {
+  if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(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 Declaration =
+      DeclarationFragmentsBuilder::getFragmentsForCXXClass(Decl);
+  DeclarationFragments SubHeading =
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+
+  APIRecord::RecordKind Kind;
+  if (Decl->isUnion())
+    Kind = APIRecord::RecordKind::RK_Union;
+  else if (Decl->isStruct())
+    Kind = APIRecord::RecordKind::RK_Struct;
+  else
+    Kind = APIRecord::RecordKind::RK_CXXClass;
+
+  CXXClassRecord *CXXClassRecord =
+      API.addCXXClass(Name, USR, Loc, AvailabilitySet(Decl), Comment,
+                      Declaration, SubHeading, Kind, isInSystemHeader(Decl));
+
+  // FIXME: store AccessSpecifier given by inheritance
+  for (const auto BaseSpecifier : Decl->bases()) {
+    // skip classes not inherited as public
+    if (BaseSpecifier.getAccessSpecifier() != AccessSpecifier::AS_public)
+      continue;
+    SymbolReference BaseClass;
+    CXXRecordDecl *BaseClassDecl =
+        BaseSpecifier.getType().getTypePtr()->getAsCXXRecordDecl();
+    BaseClass.Name = BaseClassDecl->getName();
+    BaseClass.USR = API.recordUSR(BaseClassDecl);
+    CXXClassRecord->Bases.emplace_back(BaseClass);
+  }
+
+  getDerivedExtractAPIVisitor().recordCXXFields(CXXClassRecord, Decl->fields());
+  getDerivedExtractAPIVisitor().recordCXXMethods(CXXClassRecord,
+                                                 Decl->methods());
+  return true;
+}
+
+template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitObjCInterfaceDecl(
     const ObjCInterfaceDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
 
   // Collect symbol information.
   StringRef Name = Decl->getName();
   StringRef USR = API.recordUSR(Decl);
DeclarationFragments SubHeading =
         DeclarationFragmentsBuilder::getSubHeading(Field);
 
     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());
+
+    // 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)) {
+    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));
+  DeclarationFragments SubHeading =
+      DeclarationFragmentsBuilder::getSubHeading(SpecialCXXMethod);
+  FunctionSignature Signature =
+      DeclarationFragmentsBuilder::getFunctionSignature(SpecialCXXMethod);
+  AccessControl Access =
+      DeclarationFragmentsBuilder::getAccessControl(SpecialCXXMethod);
+
+  API.addCXXMethod(CXXClassRecord, Name, USR, Loc,
+                   AvailabilitySet(SpecialCXXMethod), Comment, Declaration,
+                   SubHeading, Signature, SpecialCXXMethod->isStatic(), Access,
+                   isInSystemHeader(SpecialCXXMethod));
+}
+
+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;
+    }
+
+    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());
+
+    // 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);
+
+    API.addCXXMethod(CXXClassRecord, Name, USR, Loc, AvailabilitySet(Method),
+                     Comment, Declaration, SubHeading, Signature,
+                     Method->isStatic(), Access, isInSystemHeader(Method));
+  }
+}
+
 /// 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) {
   for (const auto *Method : Methods) {
     // Don't record selectors for properties.

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

 public:
   void traverseAPISet() {
     getDerived()->traverseGlobalVariableRecords();
 
     getDerived()->traverseGlobalFunctionRecords();
 
     getDerived()->traverseEnumRecords();
 
+    getDerived()->traverseStaticFieldRecords();
+
+    getDerived()->traverseCXXClassRecords();
+
     getDerived()->traverseStructRecords();
 
     getDerived()->traverseObjCInterfaces();
 
     getDerived()->traverseObjCProtocols();
 
     getDerived()->traverseMacroDefinitionRecords();
 
for (const auto &Enum : API.getEnums())
       getDerived()->visitEnumRecord(*Enum.second);
   }
 
   void traverseStructRecords() {
     for (const auto &Struct : API.getStructs())
       getDerived()->visitStructRecord(*Struct.second);
   }
 
+  void traverseStaticFieldRecords() {
+    for (const auto &StaticField : API.getStaticFields())
+      getDerived()->visitStaticFieldRecord(*StaticField.second);
+  }
+
+  void traverseCXXClassRecords() {
+    for (const auto &Class : API.getCXXClasses())
+      getDerived()->visitCXXClassRecord(*Class.second);
+  }
+
   void traverseObjCInterfaces() {
     for (const auto &Interface : API.getObjCInterfaces())
       getDerived()->visitObjCContainerRecord(*Interface.second);
   }
 
   void traverseObjCProtocols() {
     for (const auto &Protocol : API.getObjCProtocols())
       getDerived()->visitObjCContainerRecord(*Protocol.second);
public:
   void visitGlobalVariableRecord(const GlobalVariableRecord &Record){};
 
   /// Visit an enum record.
   void visitEnumRecord(const EnumRecord &Record){};
 
   /// Visit a struct record.
   void visitStructRecord(const StructRecord &Record){};
 
+  void visitStaticFieldRecord(const StaticFieldRecord &Record){};
+
+  void visitCXXClassRecord(const CXXClassRecord &Record){};
+
   /// Visit an Objective-C container record.
   void visitObjCContainerRecord(const ObjCContainerRecord &Record){};
 
   /// Visit a macro definition record.
   void visitMacroDefinitionRecord(const MacroDefinitionRecord &Record){};
 
   /// Visit a typedef record.
   void visitTypedefRecord(const TypedefRecord &Record){};

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

public:
   void visitGlobalVariableRecord(const GlobalVariableRecord &Record);
 
   /// Visit an enum record.
   void visitEnumRecord(const EnumRecord &Record);
 
   /// Visit a struct record.
   void visitStructRecord(const StructRecord &Record);
 
+  void visitStaticFieldRecord(const StaticFieldRecord &Record);
+
+  void visitCXXClassRecord(const CXXClassRecord &Record);
+
   /// Visit an Objective-C container record.
   void visitObjCContainerRecord(const ObjCContainerRecord &Record);
 
   /// Visit a macro definition record.
   void visitMacroDefinitionRecord(const MacroDefinitionRecord &Record);
 
   /// Visit a typedef record.
   void visitTypedefRecord(const TypedefRecord &Record);

clang/lib/ExtractAPI/API.cpp

 /// and the APISet class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/ExtractAPI/API.h"
 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/AST/CommentLexer.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/Index/USRGeneration.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 
 using namespace clang::extractapi;
 using namespace llvm;
 
 namespace {
 
 template <typename RecordTy, typename... CtorArgsTy>
 RecordTy *addTopLevelRecord(DenseMap<StringRef, APIRecord *> &USRLookupTable,
                             APISet::RecordMap<RecordTy> &RecordMap,
                             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>(USR, std::forward<CtorArgsTy>(CtorArgs)...);
 
   auto *Record = Result.first->second.get();
   USRLookupTable.insert({USR, Record});
   return Record;
 }
 
 } // namespace
 
 GlobalVariableRecord *
 APISet::addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,
                      AvailabilitySet Availabilities, LinkageInfo Linkage,
                      const DocComment &Comment, DeclarationFragments Fragments,
                      DeclarationFragments SubHeading, bool IsFromSystemHeader) {
   return addTopLevelRecord(USRBasedLookupTable, GlobalVariables, USR, Name, Loc,
StructRecord *APISet::addStruct(StringRef Name, StringRef USR, PresumedLoc Loc,
                                 DeclarationFragments Declaration,
                                 DeclarationFragments SubHeading,
                                 bool IsFromSystemHeader) {
   return addTopLevelRecord(USRBasedLookupTable, Structs, USR, Name, Loc,
                            std::move(Availabilities), Comment, Declaration,
                            SubHeading, IsFromSystemHeader);
 }
 
+StaticFieldRecord *
+APISet::addStaticField(StringRef Name, StringRef USR, PresumedLoc Loc,
+                       AvailabilitySet Availabilities, LinkageInfo Linkage,
+                       const DocComment &Comment,
+                       DeclarationFragments Declaration,
+                       DeclarationFragments SubHeading, SymbolReference Context,
+                       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,
+                    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);
+  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();
+}
+
+CXXClassRecord *
+APISet::addCXXClass(StringRef Name, StringRef USR, PresumedLoc Loc,
+                    AvailabilitySet Availabilities, const DocComment &Comment,
+                    DeclarationFragments Declaration,
+                    DeclarationFragments SubHeading, APIRecord::RecordKind Kind,
+                    bool IsFromSystemHeader) {
+  return addTopLevelRecord(USRBasedLookupTable, CXXClasses, USR, Name, Loc,
+                           std::move(Availabilities), Comment, Declaration,
+                           SubHeading, Kind, 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,
+        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();
+}
+
+CXXMethodRecord *APISet::addCXXSpecialMethod(
+    CXXClassRecord *CXXClassRecord, StringRef Name, StringRef USR,
+    PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,
+    DeclarationFragments Declaration, DeclarationFragments SubHeading,
+    FunctionSignature Signature, bool IsConstructor, 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,
+        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();
+}
+
 ObjCCategoryRecord *APISet::addObjCCategory(
     StringRef Name, StringRef USR, PresumedLoc Loc,
     AvailabilitySet Availabilities, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading,
     SymbolReference Interface, bool IsFromSystemHeader) {
   // Create the category record.
   auto *Record =
       addTopLevelRecord(USRBasedLookupTable, ObjCCategories, USR, Name, Loc,
StringRef APISet::copyString(StringRef String) {
   memcpy(Ptr, String.data(), String.size());
   return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
 }
 
 APIRecord::~APIRecord() {}
 ObjCContainerRecord::~ObjCContainerRecord() {}
 ObjCMethodRecord::~ObjCMethodRecord() {}
 ObjCPropertyRecord::~ObjCPropertyRecord() {}
+CXXMethodRecord::~CXXMethodRecord() {}
 
 void GlobalFunctionRecord::anchor() {}
 void GlobalVariableRecord::anchor() {}
 void EnumConstantRecord::anchor() {}
 void EnumRecord::anchor() {}
 void StructFieldRecord::anchor() {}
 void StructRecord::anchor() {}
+void CXXFieldRecord::anchor() {}
+void CXXClassRecord::anchor() {}
+void CXXConstructorRecord::anchor() {}
+void CXXDestructorRecord::anchor() {}
+void CXXInstanceMethodRecord::anchor() {}
+void CXXStaticMethodRecord::anchor() {}
 void ObjCInstancePropertyRecord::anchor() {}
 void ObjCClassPropertyRecord::anchor() {}
 void ObjCInstanceVariableRecord::anchor() {}
 void ObjCInstanceMethodRecord::anchor() {}
 void ObjCClassMethodRecord::anchor() {}
 void ObjCCategoryRecord::anchor() {}
 void ObjCInterfaceRecord::anchor() {}
 void ObjCProtocolRecord::anchor() {}
 void MacroDefinitionRecord::anchor() {}
 void TypedefRecord::anchor() {}

clang/lib/ExtractAPI/DeclarationFragments.cpp

 //===- ExtractAPI/DeclarationFragments.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements Declaration Fragments related classes.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/ExtractAPI/DeclarationFragments.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/Basic/OperatorKinds.h"
 #include "clang/ExtractAPI/TypedefUnderlyingTypeResolver.h"
 #include "clang/Index/USRGeneration.h"
+#include "clang/Parse/Parser.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace clang::extractapi;
 using namespace llvm;
 
 DeclarationFragments &DeclarationFragments::appendSpace() {
   if (!Fragments.empty()) {
     Fragment &Last = Fragments.back();
return llvm::StringSwitch<FragmentKind>(S)
       .Case("genericParameter",
             DeclarationFragments::FragmentKind::GenericParameter)
       .Case("internalParam", DeclarationFragments::FragmentKind::InternalParam)
       .Case("externalParam", DeclarationFragments::FragmentKind::ExternalParam)
       .Case("text", DeclarationFragments::FragmentKind::Text)
       .Default(DeclarationFragments::FragmentKind::None);
 }
 
+DeclarationFragments DeclarationFragments::getExceptionSpecificationString(
+    ExceptionSpecificationType ExceptionSpec) {
+  DeclarationFragments Fragments;
+  switch (ExceptionSpec) {
+  case ExceptionSpecificationType::EST_None:
+    return Fragments;
+  case ExceptionSpecificationType::EST_DynamicNone:
+    return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
+        .append("throw", DeclarationFragments::FragmentKind::Keyword)
+        .append("(", DeclarationFragments::FragmentKind::Text)
+        .append(")", DeclarationFragments::FragmentKind::Text);
+  case ExceptionSpecificationType::EST_Dynamic:
+    // FIXME: throw(int), get types of inner expression
+    return Fragments;
+  case ExceptionSpecificationType::EST_BasicNoexcept:
+
+    return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
+        .append("noexcept", DeclarationFragments::FragmentKind::Keyword);
+  case ExceptionSpecificationType::EST_DependentNoexcept:
+    // FIXME: throw(conditional-expression), get expression
+    break;
+  case ExceptionSpecificationType::EST_NoexceptFalse:
+    return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
+        .append("noexcept", DeclarationFragments::FragmentKind::Keyword)
+        .append("(", DeclarationFragments::FragmentKind::Text)
+        .append("false", DeclarationFragments::FragmentKind::Keyword)
+        .append(")", DeclarationFragments::FragmentKind::Text);
+  case ExceptionSpecificationType::EST_NoexceptTrue:
+    return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
+        .append("noexcept", DeclarationFragments::FragmentKind::Keyword)
+        .append("(", DeclarationFragments::FragmentKind::Text)
+        .append("true", DeclarationFragments::FragmentKind::Keyword)
+        .append(")", DeclarationFragments::FragmentKind::Text);
+  default:
+    return Fragments;
+  }
+
+  llvm_unreachable("Unhandled exception specification");
+}
+
+DeclarationFragments
+DeclarationFragments::getStructureTypeFragment(const RecordDecl *Record) {
+  DeclarationFragments Fragments;
+  if (Record->isStruct())
+    Fragments.append("struct", DeclarationFragments::FragmentKind::Keyword);
+  else if (Record->isUnion())
+    Fragments.append("union", DeclarationFragments::FragmentKind::Keyword);
+  else
+    Fragments.append("class", DeclarationFragments::FragmentKind::Keyword);
+
+  return Fragments;
+}
+
 // NNS stores C++ nested name specifiers, which are prefixes to qualified names.
 // Build declaration fragments for NNS recursively so that we have the USR for
 // every part in a qualified name, and also leaves the actual underlying type
 // cleaner for its own fragment.
 DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForNNS(const NestedNameSpecifier *NNS,
                                                 ASTContext &Context,
                                                 DeclarationFragments &After) {
if (SQT.Ty->isAnyPointerType())
     return TypeFragments.appendSpace().append(std::move(QualsFragments));
 
   return QualsFragments.appendSpace().append(std::move(TypeFragments));
 }
 
 DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForVar(const VarDecl *Var) {
   DeclarationFragments Fragments;
+  if (Var->isConstexpr())
+    Fragments.append("constexpr ", DeclarationFragments::FragmentKind::Keyword);
+
   StorageClass SC = Var->getStorageClass();
   if (SC != SC_None)
     Fragments
         .append(VarDecl::getStorageClassSpecifierString(SC),
                 DeclarationFragments::FragmentKind::Keyword)
         .appendSpace();
   QualType T =
       Var->getTypeSourceInfo()
DeclarationFragmentsBuilder::getFragmentsForFunction(const FunctionDecl *Func) {
   case SC_Static:
     Fragments.append("static", DeclarationFragments::FragmentKind::Keyword)
         .appendSpace();
     break;
   case SC_Auto:
   case SC_Register:
     llvm_unreachable("invalid for functions");
   }
-  // FIXME: Handle C++ function specifiers: constexpr, consteval, explicit, etc.
+  if (Func->isConsteval()) // if consteval, it is also constexpr
+    Fragments.append("consteval ", DeclarationFragments::FragmentKind::Keyword);
+  else if (Func->isConstexpr())
+    Fragments.append("constexpr ", DeclarationFragments::FragmentKind::Keyword);
 
   // FIXME: Is `after` actually needed here?
   DeclarationFragments After;
   Fragments
       .append(getFragmentsForType(Func->getReturnType(), Func->getASTContext(),
                                   After))
       .appendSpace()
       .append(Func->getName(), DeclarationFragments::FragmentKind::Identifier)
       .append(std::move(After));
 
   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
   for (unsigned i = 0, end = Func->getNumParams(); i != end; ++i) {
     if (i)
       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
     Fragments.append(getFragmentsForParam(Func->getParamDecl(i)));
   }
   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
 
+  Fragments.append(DeclarationFragments::getExceptionSpecificationString(
+      Func->getExceptionSpecType()));
+
   // FIXME: Handle exception specifiers: throw, noexcept
   return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
 }
 
 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForEnumConstant(
     const EnumConstantDecl *EnumConstDecl) {
   DeclarationFragments Fragments;
   return Fragments.append(EnumConstDecl->getName(),
Fragments.append(": ", DeclarationFragments::FragmentKind::Text)
         .append(std::move(After));
 
   return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
 }
 
 DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForField(const FieldDecl *Field) {
   DeclarationFragments After;
-  return getFragmentsForType(Field->getType(), Field->getASTContext(), After)
+  DeclarationFragments Fragments;
+  if (Field->isMutable())
+    Fragments.append("mutable", DeclarationFragments::FragmentKind::Keyword)
+        .appendSpace();
+  return Fragments
+      .append(
+          getFragmentsForType(Field->getType(), Field->getASTContext(), After))
       .appendSpace()
       .append(Field->getName(), DeclarationFragments::FragmentKind::Identifier)
       .append(std::move(After))
       .append(";", DeclarationFragments::FragmentKind::Text);
 }
 
 DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForStruct(const RecordDecl *Record) {
   if (const auto *TypedefNameDecl = Record->getTypedefNameForAnonDecl())
     return getFragmentsForTypedef(TypedefNameDecl);
 
   DeclarationFragments Fragments;
   Fragments.append("struct", DeclarationFragments::FragmentKind::Keyword);
 
   if (!Record->getName().empty())
     Fragments.appendSpace().append(
         Record->getName(), DeclarationFragments::FragmentKind::Identifier);
 
   return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
 }
 
+DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForCXXClass(
+    const CXXRecordDecl *Record) {
+  if (const auto *TypedefNameDecl = Record->getTypedefNameForAnonDecl())
+    return getFragmentsForTypedef(TypedefNameDecl);
+
+  DeclarationFragments Fragments;
+  Fragments.append(DeclarationFragments::getStructureTypeFragment(Record));
+
+  if (!Record->getName().empty())
+    Fragments.appendSpace().append(
+        Record->getName(), DeclarationFragments::FragmentKind::Identifier);
+
+  return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
+}
+
+DeclarationFragments
+DeclarationFragmentsBuilder::getFragmentsForSpecialCXXMethod(
+    const CXXMethodDecl *Method) {
+  DeclarationFragments Fragments;
+  std::string Name;
+  if (isa<CXXConstructorDecl>(Method)) {
+    auto *Constructor = dyn_cast<CXXConstructorDecl>(Method);
+    Name = cast<CXXRecordDecl>(Constructor->getDeclContext())->getName();
+    if (Constructor->isExplicit())
+      Fragments.append("explicit", DeclarationFragments::FragmentKind::Keyword)
+          .appendSpace();
+  } else if (isa<CXXDestructorDecl>(Method))
+    Name = Method->getNameAsString();
+
+  DeclarationFragments After;
+  Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier)
+      .append(std::move(After));
+  Fragments.append("(", DeclarationFragments::FragmentKind::Text);
+  for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
+    if (i)
+      Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
+    Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
+  }
+  Fragments.append(")", DeclarationFragments::FragmentKind::Text);
+
+  Fragments.append(DeclarationFragments::getExceptionSpecificationString(
+      Method->getExceptionSpecType()));
+
+  return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
+}
+
+DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForCXXMethod(
+    const CXXMethodDecl *Method) {
+  DeclarationFragments Fragments;
+  StringRef Name;
+  Name = Method->getName();
+  if (Method->isStatic())
+    Fragments.append("static", DeclarationFragments::FragmentKind::Keyword)
+        .appendSpace();
+  if (Method->isConstexpr())
+    Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
+        .appendSpace();
+  if (Method->isVolatile())
+    Fragments.append("volatile", DeclarationFragments::FragmentKind::Keyword)
+        .appendSpace();
+
+  // Build return type
+  DeclarationFragments After;
+  Fragments
+      .append(getFragmentsForType(Method->getReturnType(),
+                                  Method->getASTContext(), After))
+      .appendSpace()
+      .append(Name, DeclarationFragments::FragmentKind::Identifier)
+      .append(std::move(After));
+  Fragments.append("(", DeclarationFragments::FragmentKind::Text);
+  for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
+    if (i)
+      Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
+    Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
+  }
+  Fragments.append(")", DeclarationFragments::FragmentKind::Text);
+
+  if (Method->isConst())
+    Fragments.appendSpace().append("const",
+                                   DeclarationFragments::FragmentKind::Keyword);
+
+  Fragments.append(DeclarationFragments::getExceptionSpecificationString(
+      Method->getExceptionSpecType()));
+
+  return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
+}
+
+DeclarationFragments
+DeclarationFragmentsBuilder::getFragmentsForConversionFunction(
+    const CXXConversionDecl *ConversionFunction) {
+  DeclarationFragments Fragments;
+
+  if (ConversionFunction->isExplicit())
+    Fragments.append("explicit", DeclarationFragments::FragmentKind::Keyword)
+        .appendSpace();
+
+  Fragments.append("operator", DeclarationFragments::FragmentKind::Keyword)
+      .appendSpace();
+
+  Fragments
+      .append(ConversionFunction->getConversionType().getAsString(),
+              DeclarationFragments::FragmentKind::TypeIdentifier)
+      .append("(", DeclarationFragments::FragmentKind::Text);
+  for (unsigned i = 0, end = ConversionFunction->getNumParams(); i != end;
+       ++i) {
+    if (i)
+      Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
+    Fragments.append(getFragmentsForParam(ConversionFunction->getParamDecl(i)));
+  }
+  Fragments.append(")", DeclarationFragments::FragmentKind::Text);
+
+  if (ConversionFunction->isConst())
+    Fragments.appendSpace().append("const",
+                                   DeclarationFragments::FragmentKind::Keyword);
+
+  return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
+}
+
+DeclarationFragments
+DeclarationFragmentsBuilder::getFragmentsForOverloadedOperator(
+    const CXXMethodDecl *Method) {
+  DeclarationFragments Fragments;
+
+  // Build return type
+  DeclarationFragments After;
+  Fragments
+      .append(getFragmentsForType(Method->getReturnType(),
+                                  Method->getASTContext(), After))
+      .appendSpace()
+      .append(Method->getNameAsString(),
+              DeclarationFragments::FragmentKind::Identifier)
+      .append(std::move(After));
+  Fragments.append("(", DeclarationFragments::FragmentKind::Text);
+  for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
+    if (i)
+      Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
+    Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
+  }
+  Fragments.append(")", DeclarationFragments::FragmentKind::Text);
+
+  if (Method->isConst())
+    Fragments.appendSpace().append("const",
+                                   DeclarationFragments::FragmentKind::Keyword);
+
+  Fragments.append(DeclarationFragments::getExceptionSpecificationString(
+      Method->getExceptionSpecType()));
+
+  return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
+}
+
 DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForMacro(StringRef Name,
                                                   const MacroDirective *MD) {
   DeclarationFragments Fragments;
   Fragments.append("#define", DeclarationFragments::FragmentKind::Keyword)
       .appendSpace();
   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
 
Fragments.append("typedef", DeclarationFragments::FragmentKind::Keyword)
                                   Decl->getASTContext(), After))
       .append(std::move(After))
       .appendSpace()
       .append(Decl->getName(), DeclarationFragments::FragmentKind::Identifier);
 
   return Fragments.append(";", DeclarationFragments::FragmentKind::Text);
 }
 
-template <typename FunctionT>
-FunctionSignature
-DeclarationFragmentsBuilder::getFunctionSignature(const FunctionT *Function) {
-  FunctionSignature Signature;
-
-  DeclarationFragments ReturnType, After;
-  ReturnType
-      .append(getFragmentsForType(Function->getReturnType(),
-                                  Function->getASTContext(), After))
-      .append(std::move(After));
-  Signature.setReturnType(ReturnType);
-
-  for (const auto *Param : Function->parameters())
-    Signature.addParameter(Param->getName(), getFragmentsForParam(Param));
-
-  return Signature;
-}
-
 // Instantiate template for FunctionDecl.
 template FunctionSignature
 DeclarationFragmentsBuilder::getFunctionSignature(const FunctionDecl *);
 
 // Instantiate template for ObjCMethodDecl.
 template FunctionSignature
 DeclarationFragmentsBuilder::getFunctionSignature(const ObjCMethodDecl *);
 
 // Subheading of a symbol defaults to its name.
 DeclarationFragments
 DeclarationFragmentsBuilder::getSubHeading(const NamedDecl *Decl) {
   DeclarationFragments Fragments;
-  if (!Decl->getName().empty())
+  if (isa<CXXConstructorDecl>(Decl) || isa<CXXDestructorDecl>(Decl))
+    Fragments.append(cast<CXXRecordDecl>(Decl->getDeclContext())->getName(),
+                     DeclarationFragments::FragmentKind::Identifier);
+  else if (isa<CXXConversionDecl>(Decl)) {
+    Fragments.append(
+        cast<CXXConversionDecl>(Decl)->getConversionType().getAsString(),
+        DeclarationFragments::FragmentKind::Identifier);
+  } else if (isa<CXXMethodDecl>(Decl) &&
+             cast<CXXMethodDecl>(Decl)->isOverloadedOperator()) {
+    Fragments.append(Decl->getNameAsString(),
+                     DeclarationFragments::FragmentKind::Identifier);
+  } else if (!Decl->getName().empty())
     Fragments.append(Decl->getName(),
                      DeclarationFragments::FragmentKind::Identifier);
   return Fragments;
 }
 
 // Subheading of an Objective-C method is a `+` or `-` sign indicating whether
 // it's a class method or an instance method, followed by the selector name.
 DeclarationFragments

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 
 /// Helper function to inject a JSON object \p Obj into another object \p Paren
 /// at position \p Key.
 void serializeObject(Object &Paren, StringRef Key, std::optional<Object> Obj) {
   if (Obj)
     Paren[Key] = std::move(*Obj);
 }
 
+/// Helper function to inject a StringRef \p String into an object \p Paren at
+/// position \p Key
+void serializeString(Object &Paren, StringRef Key,
+                     std::optional<std::string> String) {
+  if (String)
+    Paren[Key] = std::move(*String);
+}
+
 /// Helper function to inject a JSON array \p Array into object \p Paren at
 /// position \p Key.
 void serializeArray(Object &Paren, StringRef Key, std::optional<Array> Array) {
   if (Array)
     Paren[Key] = std::move(*Array);
 }
 
 /// Serialize a \c VersionTuple \p V with the Symbol Graph semantic version

 
 /// Get the language name string for interface language references.
 StringRef getLanguageName(Language Lang) {
   switch (Lang) {
   case Language::C:
     return "c";
   case Language::ObjC:
     return "objective-c";
+  case Language::CXX:
+    return "c++";
 
   // Unsupported language currently
-  case Language::CXX:
   case Language::ObjCXX:
   case Language::OpenCL:
   case Language::OpenCLCXX:
   case Language::CUDA:
   case Language::RenderScript:
   case Language::HIP:
   case Language::HLSL:
 
Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) {
   case APIRecord::RK_StructField:
     Kind["identifier"] = AddLangPrefix("property");
     Kind["displayName"] = "Instance Property";
     break;
   case APIRecord::RK_Struct:
     Kind["identifier"] = AddLangPrefix("struct");
     Kind["displayName"] = "Structure";
     break;
+  case APIRecord::RK_CXXField:
+    Kind["identifier"] = AddLangPrefix("property");
+    Kind["displayName"] = "Instance Property";
+    break;
+  case APIRecord::RK_Union:
+    Kind["identifier"] = AddLangPrefix("union");
+    Kind["displayName"] = "Union";
+    break;
+  case APIRecord::RK_StaticField:
+    Kind["identifier"] = AddLangPrefix("type.property");
+    Kind["displayName"] = "Type Property";
+    break;
+  case APIRecord::RK_CXXClass:
+    Kind["identifier"] = AddLangPrefix("class");
+    Kind["displayName"] = "Class";
+    break;
+  case APIRecord::RK_CXXStaticMethod:
+    Kind["identifier"] = AddLangPrefix("type.method");
+    Kind["displayName"] = "Static Method";
+    break;
+  case APIRecord::RK_CXXInstanceMethod:
+    Kind["identifier"] = AddLangPrefix("method");
+    Kind["displayName"] = "Instance Method";
+    break;
+  case APIRecord::RK_CXXConstructorMethod:
+    Kind["identifier"] = AddLangPrefix("method");
+    Kind["displayName"] = "Constructor";
+    break;
+  case APIRecord::RK_CXXDestructorMethod:
+    Kind["identifier"] = AddLangPrefix("method");
+    Kind["displayName"] = "Destructor";
+    break;
   case APIRecord::RK_ObjCIvar:
     Kind["identifier"] = AddLangPrefix("ivar");
     Kind["displayName"] = "Instance Variable";
     break;
   case APIRecord::RK_ObjCInstanceMethod:
     Kind["identifier"] = AddLangPrefix("method");
     Kind["displayName"] = "Instance Method";
     break;

 /// formatted function signature.
 template <typename RecordTy>
 void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) {
   serializeObject(Paren, "functionSignature",
                   serializeFunctionSignatureMixinImpl(
                       Record, has_function_signature<RecordTy>()));
 }
 
+template <typename RecordTy>
+std::optional<std::string> serializeAccessMixinImpl(const RecordTy &Record,
+                                                    std::true_type) {
+  const auto &AccessControl = Record.Access;
+  std::string Access;
+  if (AccessControl.empty())
+    return std::nullopt;
+  Access = AccessControl.getAccess();
+  return Access;
+}
+
+template <typename RecordTy>
+std::optional<std::string> serializeAccessMixinImpl(const RecordTy &Record,
+                                                    std::false_type) {
+  return std::nullopt;
+}
+
+template <typename RecordTy>
+void serializeAccessMixin(Object &Paren, const RecordTy &Record) {
+  auto accessLevel = serializeAccessMixinImpl(Record, has_access<RecordTy>());
+  if (!accessLevel.has_value())
+    accessLevel = "public";
+  serializeString(Paren, "accessLevel", accessLevel);
+}
+
 struct PathComponent {
   StringRef USR;
   StringRef Name;
   APIRecord::RecordKind Kind;
 
   PathComponent(StringRef USR, StringRef Name, APIRecord::RecordKind Kind)
       : USR(USR), Name(Name), Kind(Kind) {}
 };
Array generateParentContexts(const RecordTy &Record, const APISet &API,
   Array ParentContexts;
   generatePathComponents(
       Record, API, [Lang, &ParentContexts](const PathComponent &PC) {
         ParentContexts.push_back(serializeParentContext(PC, Lang));
       });
 
   return ParentContexts;
 }
-
 } // namespace
 
 /// Defines the format version emitted by SymbolGraphSerializer.
 const VersionTuple SymbolGraphSerializer::FormatVersion{0, 5, 3};
 
 Object SymbolGraphSerializer::serializeMetadata() const {
   Object Metadata;
   serializeObject(Metadata, "formatVersion",
SymbolGraphSerializer::serializeAPIRecord(const RecordTy &Record) const {
   serializeObject(
       Obj, "location",
       serializeSourceLocation(Record.Location, /*IncludeFileURI=*/true));
   serializeArray(Obj, "availability",
                  serializeAvailability(Record.Availabilities));
   serializeObject(Obj, "docComment", serializeDocComment(Record.Comment));
   serializeArray(Obj, "declarationFragments",
                  serializeDeclarationFragments(Record.Declaration));
-  // TODO: Once we keep track of symbol access information serialize it
-  // correctly here.
-  Obj["accessLevel"] = "public";
   SmallVector<StringRef, 4> PathComponentsNames;
   // If this returns true it indicates that we couldn't find a symbol in the
   // hierarchy.
   if (generatePathComponents(Record, API,
                              [&PathComponentsNames](const PathComponent &PC) {
                                PathComponentsNames.push_back(PC.Name);
                              }))
     return {};
 
   serializeArray(Obj, "pathComponents", Array(PathComponentsNames));
 
   serializeFunctionSignatureMixin(Obj, Record);
+  serializeAccessMixin(Obj, Record);
 
   return Obj;
 }
 
 template <typename MemberTy>
 void SymbolGraphSerializer::serializeMembers(
     const APIRecord &Record,
     const SmallVector<std::unique_ptr<MemberTy>> &Members) {
void SymbolGraphSerializer::visitStructRecord(const StructRecord &Record) {
   auto Struct = serializeAPIRecord(Record);
   if (!Struct)
     return;
 
   Symbols.emplace_back(std::move(*Struct));
   serializeMembers(Record, Record.Fields);
 }
 
+void SymbolGraphSerializer::visitStaticFieldRecord(
+    const StaticFieldRecord &Record) {
+  auto StaticField = serializeAPIRecord(Record);
+  if (!StaticField)
+    return;
+  Symbols.emplace_back(std::move(*StaticField));
+  serializeRelationship(RelationshipKind::MemberOf, Record, Record.Context);
+}
+
+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::visitObjCContainerRecord(
     const ObjCContainerRecord &Record) {
   auto ObjCContainer = serializeAPIRecord(Record);
   if (!ObjCContainer)
     return;
 
   Symbols.emplace_back(std::move(*ObjCContainer));
 
case APIRecord::RK_GlobalVariable:
     visitGlobalVariableRecord(*cast<GlobalVariableRecord>(Record));
     break;
   case APIRecord::RK_Enum:
     visitEnumRecord(*cast<EnumRecord>(Record));
     break;
   case APIRecord::RK_Struct:
     visitStructRecord(*cast<StructRecord>(Record));
     break;
+  case APIRecord::RK_StaticField:
+    visitStaticFieldRecord(*cast<StaticFieldRecord>(Record));
+    break;
+  case APIRecord::RK_CXXClass:
+    visitCXXClassRecord(*cast<CXXClassRecord>(Record));
+    break;
   case APIRecord::RK_ObjCInterface:
     visitObjCContainerRecord(*cast<ObjCInterfaceRecord>(Record));
     break;
   case APIRecord::RK_ObjCProtocol:
     visitObjCContainerRecord(*cast<ObjCProtocolRecord>(Record));
     break;
   case APIRecord::RK_MacroDefinition:
     visitMacroDefinitionRecord(*cast<MacroDefinitionRecord>(Record));

clang/test/ExtractAPI/class.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {
+private:
+  int a;
+  mutable int b;
+
+protected:
+  int c;
+
+public:
+  int d;
+};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@FI@a",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@FI@b",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@FI@c",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@FI@d",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "a"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@FI@a"
+      },
+      "kind": {
+        "displayName": "Instance Property",
+        "identifier": "c++.property"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "a"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "a"
+          }
+        ],
+        "title": "a"
+      },
+      "pathComponents": [
+        "Foo",
+        "a"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "mutable"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "b"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@FI@b"
+      },
+      "kind": {
+        "displayName": "Instance Property",
+        "identifier": "c++.property"
+      },
+      "location": {
+        "position": {
+          "character": 15,
+          "line": 4
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "b"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "b"
+          }
+        ],
+        "title": "b"
+      },
+      "pathComponents": [
+        "Foo",
+        "b"
+      ]
+    },
+    {
+      "accessLevel": "protected",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "c"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@FI@c"
+      },
+      "kind": {
+        "displayName": "Instance Property",
+        "identifier": "c++.property"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 7
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "c"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "c"
+          }
+        ],
+        "title": "c"
+      },
+      "pathComponents": [
+        "Foo",
+        "c"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "d"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@FI@d"
+      },
+      "kind": {
+        "displayName": "Instance Property",
+        "identifier": "c++.property"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 10
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "d"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "d"
+          }
+        ],
+        "title": "d"
+      },
+      "pathComponents": [
+        "Foo",
+        "d"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/constructor_destructor.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {
+  Foo();
+  ~Foo();
+};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@Foo#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@~Foo#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@Foo#"
+      },
+      "kind": {
+        "displayName": "Constructor",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 3,
+          "line": 2
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo",
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "identifier",
+          "spelling": "~Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@~Foo#"
+      },
+      "kind": {
+        "displayName": "Destructor",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 3,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "~Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "~Foo"
+      },
+      "pathComponents": [
+        "Foo",
+        "~Foo"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/conversions.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {
+  operator int();
+  explicit operator double();
+};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@operator int#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@operator double#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "operator"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "typeIdentifier",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:I",
+            "spelling": "int"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@operator int#"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 3,
+          "line": 2
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "operator int"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "int"
+          }
+        ],
+        "title": "operator int"
+      },
+      "pathComponents": [
+        "Foo",
+        "operator int"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "explicit"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "operator"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "typeIdentifier",
+          "spelling": "double"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:d",
+            "spelling": "double"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@operator double#"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 12,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "operator double"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "double"
+          }
+        ],
+        "title": "operator double"
+      },
+      "pathComponents": [
+        "Foo",
+        "operator double"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/function_noexcepts.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+void getFoo() noexcept;
+
+void getBar() noexcept(true);
+
+void getFooBar() noexcept(false);
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getFoo"
+        },
+        {
+          "kind": "text",
+          "spelling": "()"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "noexcept"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@F@getFoo#"
+      },
+      "kind": {
+        "displayName": "Function",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 6,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getFoo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getFoo"
+          }
+        ],
+        "title": "getFoo"
+      },
+      "pathComponents": [
+        "getFoo"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getBar"
+        },
+        {
+          "kind": "text",
+          "spelling": "()"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "noexcept"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "keyword",
+          "spelling": "true"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@F@getBar#"
+      },
+      "kind": {
+        "displayName": "Function",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 6,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getBar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getBar"
+          }
+        ],
+        "title": "getBar"
+      },
+      "pathComponents": [
+        "getBar"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getFooBar"
+        },
+        {
+          "kind": "text",
+          "spelling": "()"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "noexcept"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "keyword",
+          "spelling": "false"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@F@getFooBar#"
+      },
+      "kind": {
+        "displayName": "Function",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 6,
+          "line": 5
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getFooBar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getFooBar"
+          }
+        ],
+        "title": "getFooBar"
+      },
+      "pathComponents": [
+        "getFooBar"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/methods.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {
+  int getCount();
+
+  void setLength(int length) noexcept;
+
+public:
+  static double getFoo();
+
+protected:
+  constexpr int getBar() const;
+};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@getCount#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@setLength#I#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@getFoo#S",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@getBar#1",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getCount"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:I",
+            "spelling": "int"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@getCount#"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 2
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getCount"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getCount"
+          }
+        ],
+        "title": "getCount"
+      },
+      "pathComponents": [
+        "Foo",
+        "getCount"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "setLength"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "length"
+        },
+        {
+          "kind": "text",
+          "spelling": ")"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "noexcept"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:I",
+                "spelling": "int"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "length"
+              }
+            ],
+            "name": "length"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@setLength#I#"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 8,
+          "line": 4
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "setLength"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "setLength"
+          }
+        ],
+        "title": "setLength"
+      },
+      "pathComponents": [
+        "Foo",
+        "setLength"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "static"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:d",
+          "spelling": "double"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getFoo"
+        },
+        {
+          "kind": "text",
+          "spelling": "();"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:d",
+            "spelling": "double"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@getFoo#S"
+      },
+      "kind": {
+        "displayName": "Static Method",
+        "identifier": "c++.type.method"
+      },
+      "location": {
+        "position": {
+          "character": 17,
+          "line": 7
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getFoo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getFoo"
+          }
+        ],
+        "title": "getFoo"
+      },
+      "pathComponents": [
+        "Foo",
+        "getFoo"
+      ]
+    },
+    {
+      "accessLevel": "protected",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "constexpr"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "getBar"
+        },
+        {
+          "kind": "text",
+          "spelling": "() "
+        },
+        {
+          "kind": "keyword",
+          "spelling": "const"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:I",
+            "spelling": "int"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@getBar#1"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 17,
+          "line": 10
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "getBar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "getBar"
+          }
+        ],
+        "title": "getBar"
+      },
+      "pathComponents": [
+        "Foo",
+        "getBar"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/multiple_inheritance.cpp

+
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Fizz {};
+
+class Foo : public Fizz {};
+
+class Bar : public Fizz {};
+
+class FooBar : public Foo, public Bar{};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "inheritsFrom",
+      "source": "c:@S@Foo",
+      "target": "c:@S@Fizz",
+      "targetFallback": "Fizz"
+    },
+    {
+      "kind": "inheritsFrom",
+      "source": "c:@S@Bar",
+      "target": "c:@S@Fizz",
+      "targetFallback": "Fizz"
+    },
+    {
+      "kind": "inheritsFrom",
+      "source": "c:@S@FooBar",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    },
+    {
+      "kind": "inheritsFrom",
+      "source": "c:@S@FooBar",
+      "target": "c:@S@Bar",
+      "targetFallback": "Bar"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Fizz"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Fizz"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Fizz"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Fizz"
+          }
+        ],
+        "title": "Fizz"
+      },
+      "pathComponents": [
+        "Fizz"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Bar"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Bar"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 5
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Bar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Bar"
+          }
+        ],
+        "title": "Bar"
+      },
+      "pathComponents": [
+        "Bar"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "FooBar"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@FooBar"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 7
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "FooBar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "FooBar"
+          }
+        ],
+        "title": "FooBar"
+      },
+      "pathComponents": [
+        "FooBar"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/operator_overload.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {
+  int operator+(int x);
+};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "memberOf",
+      "source": "c:@S@Foo@F@operator+#I#",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "private",
+      "declarationFragments": [
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "operator+"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "x"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:I",
+                "spelling": "int"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "x"
+              }
+            ],
+            "name": "x"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:I",
+            "spelling": "int"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo@F@operator+#I#"
+      },
+      "kind": {
+        "displayName": "Instance Method",
+        "identifier": "c++.method"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 2
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "operator+"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "operator+"
+          }
+        ],
+        "title": "operator+"
+      },
+      "pathComponents": [
+        "Foo",
+        "operator+"
+      ]
+    }
+  ]
+}

clang/test/ExtractAPI/simple_inheritance.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+class Foo {};
+
+class Bar : public Foo {};
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [
+    {
+      "kind": "inheritsFrom",
+      "source": "c:@S@Bar",
+      "target": "c:@S@Foo",
+      "targetFallback": "Foo"
+    }
+  ],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Foo"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "class"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Bar"
+        },
+        {
+          "kind": "text",
+          "spelling": ";"
+        }
+      ],
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@S@Bar"
+      },
+      "kind": {
+        "displayName": "Class",
+        "identifier": "c++.class"
+      },
+      "location": {
+        "position": {
+          "character": 7,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Bar"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Bar"
+          }
+        ],
+        "title": "Bar"
+      },
+      "pathComponents": [
+        "Bar"
+      ]
+    }
+  ]
+}