[clangd] Add access specifier information to hover contents

[danielmartin]

Summary

For https://github.com/clangd/clangd/issues/382

This commit adds access specifier information to the hover
contents. For example, the hover information of a class field or
member function will now indicate if the field or member is private,
public, or protected. This can be particularly useful when a developer
is in the implementation file and wants to know if a particular member
definition is public or private.

[kadircet]

thanks for taking a look at this, this looks great!

mostly nits, but the one in tests is important and annoying (it might require you to update some existing cases)

clang-tools-extra/clangd/Hover.cpp

680

it is annoying to have this function duplicated in each component (there are duplicates at least in text and json node dumpers too) :/

Feel free to provide a common implementation in clang/include/clang/Basic/Specifiers.h and migrate all other usages to it, or just put a FIXME in here saying we should converge those.

nit: prefer llvm::StringRef as return type

779

I wonder if it would be more natural to put this at bottom, where we list the containing class/struct/union. e.g.

struct X { int fo^o; }

would result in

field foo
---

// In X
public: int foo

I find current one useful too, just listing options to see what you (and possibly others interested in) think.

clang-tools-extra/clangd/Hover.h

63

Let's have std::string here, with a comment saying that Access specifier for declarations inside class/struct/unions, empty for others.

clang-tools-extra/clangd/unittests/HoverTests.cpp

730–731

could you also add an EXPECT_EQ for H->AccessSpecifier ?

[danielmartin]

Move clang::getAccess to Specifiers.h and refactor logic in clang-doc
to use that function instead of its own.

Also changes where "public", "private" etc. is shown in the hover
contents. Now it's shown at the bottom.

Strengthens an existing unit test to also check for access specifiers.

[danielmartin]

clang-tools-extra/clangd/Hover.cpp

680

I've only found usages in clang-doc, I don't know if there's more.

I've changed them to use the new common logic in Specifiers.h.

779

I think it's a bit less visible, but one good thing your suggestion has is that in the Emacs client we use that part of the hover content to show a one liner with type information. So I followed your suggestion to also have access specifier information in our one-liner.

[kadircet]

thanks! LGTM with some minor comments.

let me know if you don't have commit access so that i can land this for you.

clang-tools-extra/clangd/Hover.cpp

470–472

nit: you can do getAccess(D->getAccess()).str() (same for other places as well)

680

there's also some in https://github.com/llvm/llvm-project/blob/master/clang/lib/AST/DeclPrinter.cpp#L291

• https://github.com/llvm/llvm-project/blob/master/clang/lib/AST/DeclPrinter.cpp#L997
• https://github.com/llvm/llvm-project/blob/master/clang/lib/AST/DeclPrinter.cpp#L432
• https://github.com/llvm/llvm-project/blob/master/clang/include/clang/AST/JSONNodeDumper.h#L163
• https://github.com/llvm/llvm-project/blob/master/clang/include/clang/AST/TextNodeDumper.h#L186

clang-tools-extra/clangd/unittests/HoverTests.cpp

616

this is surprising, but looks like sema always instantiates template parameters with public access specifiers explicitly.

no action needed, just leaving out comments in case we want to act on it in the future.

clang/include/clang/Basic/Specifiers.h

369

getAccessSpelling instead of getAccess

[danielmartin]

Address feedback

Rename getAccess to getAccessSpelling.
Replace more parts of the codebase that were using their own version of getAccessSpelling.
Use StringRef's str() method instead of explicit std::string constructor.

[danielmartin]

Thanks for the review! I don't have commit access so I'd need someone to land this patch for me.

[kadircet]

thanks a lot, looks like you've only uploaded the diff for your latest changes(e.g. changes to clang-doc are gone). you need to squash them and upload a single diff based at master.

[danielmartin]

Rebase and squash

clang-tools-extra/clang-doc/Generators.h

public:
   static void addInfoToIndex(Index &Idx, const doc::Info *Info);
 };
 
 typedef llvm::Registry<Generator> GeneratorRegistry;
 
 llvm::Expected<std::unique_ptr<Generator>>
 findGeneratorByName(llvm::StringRef Format);
 
-std::string getAccess(AccessSpecifier AS);
-
 std::string getTagType(TagTypeKind AS);
 
 } // namespace doc
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_GENERATOR_H

clang-tools-extra/clang-doc/Generators.cpp

for (auto I = GeneratorRegistry::begin(), E = GeneratorRegistry::end();
     return I->instantiate();
   }
   return createStringError(llvm::inconvertibleErrorCode(),
                            "can't find generator: " + Format);
 }
 
 // Enum conversion
 
-std::string getAccess(AccessSpecifier AS) {
-  switch (AS) {
-  case AccessSpecifier::AS_public:
-    return "public";
-  case AccessSpecifier::AS_protected:
-    return "protected";
-  case AccessSpecifier::AS_private:
-    return "private";
-  case AccessSpecifier::AS_none:
-    return {};
-  }
-  llvm_unreachable("Unknown AccessSpecifier");
-}
-
 std::string getTagType(TagTypeKind AS) {
   switch (AS) {
   case TagTypeKind::TTK_Class:
     return "class";
   case TagTypeKind::TTK_Union:
     return "union";
   case TagTypeKind::TTK_Interface:
     return "interface";

clang-tools-extra/clang-doc/HTMLGenerator.cpp

if (Members.empty())
     return {};
 
   std::vector<std::unique_ptr<TagNode>> Out;
   Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Members"));
   Out.back()->Attributes.emplace_back("id", "Members");
   Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
   auto &ULBody = Out.back();
   for (const auto &M : Members) {
-    std::string Access = getAccess(M.Access);
+    std::string Access = getAccessSpelling(M.Access).str();
     if (Access != "")
       Access = Access + " ";
     auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
     LIBody->Children.emplace_back(std::make_unique<TextNode>(Access));
     LIBody->Children.emplace_back(genReference(M.Type, ParentInfoDir));
     LIBody->Children.emplace_back(std::make_unique<TextNode>(" " + M.Name));
     ULBody->Children.emplace_back(std::move(LIBody));
   }
genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,
   // USR is used as id for functions instead of name to disambiguate function
   // overloads.
   Out.back()->Attributes.emplace_back("id",
                                       llvm::toHex(llvm::toStringRef(I.USR)));
 
   Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
   auto &FunctionHeader = Out.back();
 
-  std::string Access = getAccess(I.Access);
+  std::string Access = getAccessSpelling(I.Access).str();
   if (Access != "")
     FunctionHeader->Children.emplace_back(
         std::make_unique<TextNode>(Access + " "));
   if (I.ReturnType.Type.Name != "") {
     FunctionHeader->Children.emplace_back(
         genReference(I.ReturnType.Type, ParentInfoDir));
     FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(" "));
   }

clang-tools-extra/clang-doc/MDGenerator.cpp

static void genMarkdown(const ClangDocContext &CDCtx, const FunctionInfo &I,
   bool First = true;
   for (const auto &N : I.Params) {
     if (!First)
       Stream << ", ";
     Stream << N.Type.Name + " " + N.Name;
     First = false;
   }
   writeHeader(I.Name, 3, OS);
-  std::string Access = getAccess(I.Access);
+  std::string Access = getAccessSpelling(I.Access).str();
   if (Access != "")
     writeLine(genItalic(Access + " " + I.ReturnType.Type.Name + " " + I.Name +
                         "(" + Stream.str() + ")"),
               OS);
   else
     writeLine(genItalic(I.ReturnType.Type.Name + " " + I.Name + "(" +
                         Stream.str() + ")"),
               OS);
if (!Parents.empty() || !VParents.empty()) {
     else
       writeLine("Inherits from " + Parents + ", " + VParents, OS);
     writeNewLine(OS);
   }
 
   if (!I.Members.empty()) {
     writeHeader("Members", 2, OS);
     for (const auto &Member : I.Members) {
-      std::string Access = getAccess(Member.Access);
+      std::string Access = getAccessSpelling(Member.Access).str();
       if (Access != "")
         writeLine(Access + " " + Member.Type.Name + " " + Member.Name, OS);
       else
         writeLine(Member.Type.Name + " " + Member.Name, OS);
     }
     writeNewLine(OS);
   }
 

clang-tools-extra/clangd/Hover.h

struct HoverInfo {
   /// Name of the symbol, does not contain any "::".
   std::string Name;
   llvm::Optional<Range> SymRange;
   index::SymbolKind Kind = index::SymbolKind::Unknown;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
 
+  /// Access specifier for declarations inside class/struct/unions, empty for
+  /// others.
+  std::string AccessSpecifier;
   /// Pretty-printed variable type.
   /// Set only for variables.
   llvm::Optional<std::string> Type;
   /// Set for functions and lambdas.
   llvm::Optional<std::string> ReturnType;
   /// Set for functions, lambdas and macros with parameters.
   llvm::Optional<std::vector<Param>> Parameters;
   /// Set for all templates(function, class, variable).

clang-tools-extra/clangd/Hover.cpp

std::string synthesizeDocumentation(const NamedDecl *ND) {
   }
   return "";
 }
 
 /// Generate a \p Hover object given the declaration \p D.
 HoverInfo getHoverContents(const NamedDecl *D, const SymbolIndex *Index) {
   HoverInfo HI;
   const ASTContext &Ctx = D->getASTContext();
 
+  HI.AccessSpecifier = getAccessSpelling(D->getAccess()).str();
   HI.NamespaceScope = getNamespaceScope(D);
   if (!HI.NamespaceScope->empty())
     HI.NamespaceScope->append("::");
   HI.LocalScope = getLocalScope(D);
   if (!HI.LocalScope.empty())
     HI.LocalScope.append("::");
 
   PrintingPolicy Policy = printingPolicyForDecls(Ctx.getPrintingPolicy());
   HI.Name = printName(Ctx, *D);
if (Record && !Record->isDependentType()) {
         HI.Size = Size->getQuantity();
         HI.Offset = OffsetBits / 8;
       }
     }
     return;
   }
 }
 
 } // namespace
 
 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                    format::FormatStyle Style,
                                    const SymbolIndex *Index) {
   const SourceManager &SM = AST.getSourceManager();
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
markup::Document HoverInfo::present() const {
   //
   // expression
   //
   // Note that we are making use of a level-3 heading because VSCode renders
   // level 1 and 2 headers in a huge font, see
   // https://github.com/microsoft/vscode/issues/88417 for details.
   markup::Paragraph &Header = Output.addHeading(3);
   if (Kind != index::SymbolKind::Unknown)
     Header.appendText(index::getSymbolKindString(Kind)).appendSpace();
   assert(!Name.empty() && "hover triggered on a nameless symbol");
   Header.appendCode(Name);
 
   // Put a linebreak after header to increase readability.
   Output.addRuler();
   // Print Types on their own lines to reduce chances of getting line-wrapped by
   // editor, as they might be long.
   if (ReturnType) {
if (!LocalScope.empty()) {
       // We might want to propagate some info about container type to print
       // function foo, class X, method X::bar, etc.
       ScopeComment =
           "// In " + llvm::StringRef(LocalScope).rtrim(':').str() + '\n';
     } else if (NamespaceScope && !NamespaceScope->empty()) {
       ScopeComment = "// In namespace " +
                      llvm::StringRef(*NamespaceScope).rtrim(':').str() + '\n';
     }
+    std::string DefinitionWithAccess = !AccessSpecifier.empty()
+                                           ? AccessSpecifier + ": " + Definition
+                                           : Definition;
     // Note that we don't print anything for global namespace, to not annoy
     // non-c++ projects or projects that are not making use of namespaces.
-    Output.addCodeBlock(ScopeComment + Definition);
+    Output.addCodeBlock(ScopeComment + DefinitionWithAccess);
   }
   return Output;
 }
 
 // If the backtick at `Offset` starts a probable quoted range, return the range
 // (including the quotes).
 llvm::Optional<llvm::StringRef> getBacktickQuoteRange(llvm::StringRef Line,
                                                       unsigned Offset) {

clang-tools-extra/clangd/unittests/HoverTests.cpp

 //===-- HoverTests.cpp ----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "AST.h"
 #include "Annotations.h"
 #include "Hover.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "index/MemIndex.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <vector>
const std::function<void(HoverInfo &)> ExpectedBuilder;
          HI.NamespaceScope = "ns1::ns2::";
          HI.LocalScope = "Foo::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "char bar";
          HI.Type = "char";
          HI.Offset = 0;
          HI.Size = 1;
+         HI.AccessSpecifier = "public";
        }},
       // Local to class method.
       {R"cpp(
           namespace ns1 { namespace ns2 {
             struct Foo {
               void foo() {
                 int [[b^ar]];
               }
const std::function<void(HoverInfo &)> ExpectedBuilder;
          HI.NamespaceScope = "ns1::";
          HI.LocalScope = "(anonymous struct)::";
          HI.Name = "bar";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "char bar";
          HI.Type = "char";
          HI.Offset = 0;
          HI.Size = 1;
+         HI.AccessSpecifier = "public";
        }},
       // Struct definition shows size.
       {R"cpp(
           struct [[^X]]{};
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "X";
class Foo {})cpp";
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "X";
          HI.LocalScope = "X<T *>::"; // FIXME: X<T *, void>::
          HI.Kind = index::SymbolKind::Constructor;
          HI.Definition = "X()";
          HI.Parameters.emplace();
+         HI.AccessSpecifier = "public";
        }},
       {"class X { [[^~]]X(); };", // FIXME: Should be [[~X]]()
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "~X";
          HI.LocalScope = "X::";
          HI.Kind = index::SymbolKind::Destructor;
          HI.Definition = "~X()";
          HI.Parameters.emplace();
+         HI.AccessSpecifier = "private";
        }},
       {"class X { [[op^erator]] int(); };",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "operator int";
          HI.LocalScope = "X::";
          HI.Kind = index::SymbolKind::ConversionFunction;
          HI.Definition = "operator int()";
          HI.Parameters.emplace();
+         HI.AccessSpecifier = "private";
        }},
       {"class X { operator [[^X]](); };",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "X";
          HI.Kind = index::SymbolKind::Class;
          HI.Definition = "class X {}";
        }},
class Foo {})cpp";
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "static constexpr int result = 1 + 2";
          HI.Kind = index::SymbolKind::StaticProperty;
          HI.Type = "const int";
          HI.NamespaceScope = "";
          HI.LocalScope = "Add<1, 2>::";
          HI.Value = "3";
+         HI.AccessSpecifier = "public";
        }},
       {R"cpp(
         constexpr int answer() { return 40 + 2; }
         int x = [[ans^wer]]();
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "answer";
          HI.Definition = "constexpr int answer()";
class Foo {})cpp";
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::TemplateTypeParm;
          HI.NamespaceScope = "";
          HI.Definition = "typename T = int";
          HI.LocalScope = "foo::";
          HI.Type = "typename";
+         HI.AccessSpecifier = "public";
        }},
       {// TemplateTemplate Type Parameter
        R"cpp(
           template <template<typename> class [[^T]]> void foo();
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::TemplateTemplateParm;
          HI.NamespaceScope = "";
          HI.Definition = "template <typename> class T";
          HI.LocalScope = "foo::";
          HI.Type = "template <typename> class";
+         HI.AccessSpecifier = "public";
        }},
       {// NonType Template Parameter
        R"cpp(
           template <int [[^T]] = 5> void foo();
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "T";
          HI.Kind = index::SymbolKind::NonTypeTemplateParm;
          HI.NamespaceScope = "";
          HI.Definition = "int T = 5";
          HI.LocalScope = "foo::";
          HI.Type = "int";
+         HI.AccessSpecifier = "public";
        }},
 
       {// Getter
        R"cpp(
           struct X { int Y; float [[^y]]() { return Y; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "y";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "float y()";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial accessor for `Y`.";
          HI.Type = "float ()";
          HI.ReturnType = "float";
          HI.Parameters.emplace();
+         HI.AccessSpecifier = "public";
        }},
       {// Setter
        R"cpp(
           struct X { int Y; void [[^setY]](float v) { Y = v; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "setY";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "void setY(float v)";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial setter for `Y`.";
          HI.Type = "void (float)";
          HI.ReturnType = "void";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
          HI.Parameters->back().Name = "v";
+         HI.AccessSpecifier = "public";
        }},
       {// Setter (builder)
        R"cpp(
           struct X { int Y; X& [[^setY]](float v) { Y = v; return *this; } };
           )cpp",
        [](HoverInfo &HI) {
          HI.Name = "setY";
          HI.Kind = index::SymbolKind::InstanceMethod;
          HI.NamespaceScope = "";
          HI.Definition = "X &setY(float v)";
          HI.LocalScope = "X::";
          HI.Documentation = "Trivial setter for `Y`.";
          HI.Type = "struct X &(float)";
          HI.ReturnType = "struct X &";
          HI.Parameters.emplace();
          HI.Parameters->emplace_back();
          HI.Parameters->back().Type = "float";
          HI.Parameters->back().Name = "v";
+         HI.AccessSpecifier = "public";
        }},
   };
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
for (const auto &Case : Cases) {
     EXPECT_EQ(H->Definition, Expected.Definition);
     EXPECT_EQ(H->Type, Expected.Type);
     EXPECT_EQ(H->ReturnType, Expected.ReturnType);
     EXPECT_EQ(H->Parameters, Expected.Parameters);
     EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
     EXPECT_EQ(H->SymRange, Expected.SymRange);
     EXPECT_EQ(H->Value, Expected.Value);
     EXPECT_EQ(H->Size, Expected.Size);
     EXPECT_EQ(H->Offset, Expected.Offset);
+    EXPECT_EQ(H->AccessSpecifier, Expected.AccessSpecifier);
   }
 }
 
 TEST(Hover, NoHover) {
   llvm::StringRef Tests[] = {
       "^int main() {}",
       "void foo() {^}",
       R"cpp(// structured binding. Not supported yet

 Type: type
 Value = value
 Offset: 12 bytes
 Size: 4 bytes
 
 // In test::Bar
 def)",
       },
-  };
+      {
+          [](HoverInfo &HI) {
+            HI.Kind = index::SymbolKind::Field;
+            HI.AccessSpecifier = "public";
+            HI.Name = "foo";
+            HI.LocalScope = "test::Bar::";
+            HI.Definition = "def";
+          },
+          R"(field foo
+
+// In test::Bar
+public: def)",
+      },
+      {
+          [](HoverInfo &HI) {
+            HI.Definition = "int method()";
+            HI.AccessSpecifier = "protected";
+            HI.Kind = index::SymbolKind::InstanceMethod;
+            HI.NamespaceScope = "";
+            HI.LocalScope = "cls<int>::";
+            HI.Name = "method";
+            HI.Parameters.emplace();
+            HI.ReturnType = "int";
+            HI.Type = "int ()";
+          },
+          R"(instance-method method
+
+→ int
+
+// In cls<int>
+protected: int method())",
+      },
+      {
+          [](HoverInfo &HI) {
+            HI.Kind = index::SymbolKind::Union;
+            HI.AccessSpecifier = "private";
+            HI.Name = "foo";
+            HI.NamespaceScope = "ns1::";
+            HI.Definition = "union foo {}";
+          },
+          R"(union foo
+
+// In namespace ns1
+private: union foo {})",
+      }};
 
   for (const auto &C : Cases) {
     HoverInfo HI;
     C.Builder(HI);
     EXPECT_EQ(HI.present().asPlainText(), C.ExpectedRender);
   }
 }
 

clang/include/clang/Basic/Specifiers.h

#include "clang/Basic/OpenCLImageTypes.def"
   enum class MSInheritanceModel {
     Single = 0,
     Multiple = 1,
     Virtual = 2,
     Unspecified = 3,
   };
 
   llvm::StringRef getParameterABISpelling(ParameterABI kind);
+
+  inline llvm::StringRef getAccessSpelling(AccessSpecifier AS) {
+    switch (AS) {
+    case AccessSpecifier::AS_public:
+      return "public";
+    case AccessSpecifier::AS_protected:
+      return "protected";
+    case AccessSpecifier::AS_private:
+      return "private";
+    case AccessSpecifier::AS_none:
+      return {};
+    }
+    llvm_unreachable("Unknown AccessSpecifier");
+  }
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_SPECIFIERS_H

clang/lib/AST/DeclPrinter.cpp

void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) {
   this->Indent();
   Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
   Out << ";\n";
   Decls.clear();
 
 }
 
 void DeclPrinter::Print(AccessSpecifier AS) {
-  switch(AS) {
-  case AS_none:      llvm_unreachable("No access specifier!");
-  case AS_public:    Out << "public"; break;
-  case AS_protected: Out << "protected"; break;
-  case AS_private:   Out << "private"; break;
-  }
+  const auto AccessSpelling = getAccessSpelling(AS);
+  if (AccessSpelling.empty())
+    llvm_unreachable("No access specifier!");
+  Out << AccessSpelling;
 }
 
 void DeclPrinter::PrintConstructorInitializers(CXXConstructorDecl *CDecl,
                                                std::string &Proto) {
   bool HasInitializerList = false;
   for (const auto *BMInitializer : CDecl->inits()) {
     if (BMInitializer->isInClassMemberInitializer())
       continue;

clang/lib/AST/JSONNodeDumper.cpp

 #include "clang/AST/JSONNodeDumper.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace clang;
 
 void JSONNodeDumper::addPreviousDeclaration(const Decl *D) {
   switch (D->getKind()) {
 #define DECL(DERIVED, BASE)                                                    \
JSONNodeDumper::createCXXRecordDefinitionData(const CXXRecordDecl *RD) {
 
   return Ret;
 }
 
 #undef FIELD1
 #undef FIELD2
 
 std::string JSONNodeDumper::createAccessSpecifier(AccessSpecifier AS) {
-  switch (AS) {
-  case AS_none: return "none";
-  case AS_private: return "private";
-  case AS_protected: return "protected";
-  case AS_public: return "public";
-  }
-  llvm_unreachable("Unknown access specifier");
+  const auto AccessSpelling = getAccessSpelling(AS);
+  if (AccessSpelling.empty())
+    return "none";
+  return AccessSpelling.str();
 }
 
 llvm::json::Object
 JSONNodeDumper::createCXXBaseSpecifier(const CXXBaseSpecifier &BS) {
   llvm::json::Object Ret;
 
   Ret["type"] = createQualType(BS.getType());
   Ret["access"] = createAccessSpecifier(BS.getAccessSpecifier());

clang/lib/AST/TextNodeDumper.cpp

 
 #include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Basic/Specifiers.h"
 
 using namespace clang;
 
 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
 
 template <typename T>
 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
   const T *First = D->getFirstDecl();

 void TextNodeDumper::dumpName(const NamedDecl *ND) {
   if (ND->getDeclName()) {
     ColorScope Color(OS, ShowColors, DeclNameColor);
     OS << ' ' << ND->getNameAsString();
   }
 }
 
 void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
-  switch (AS) {
-  case AS_none:
-    break;
-  case AS_public:
-    OS << "public";
-    break;
-  case AS_protected:
-    OS << "protected";
-    break;
-  case AS_private:
-    OS << "private";
-    break;
-  }
+  const auto AccessSpelling = getAccessSpelling(AS);
+  if (AccessSpelling.empty())
+    return;
+  OS << AccessSpelling;
 }
 
 void TextNodeDumper::dumpCleanupObject(
     const ExprWithCleanups::CleanupObject &C) {
   if (auto *BD = C.dyn_cast<BlockDecl *>())
     dumpDeclRef(BD, "cleanup");
   else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
     AddChild([=] {