[clangd] Pull AST printer helpers to Clang

[kbobyrev]

Summary

This will be needed for pulling out the stdlib header handlers from clangd into
Clang.

[kbobyrev]

Fix the build

clang-tools-extra/clangd/AST.h

 bool isImplementationDetail(const Decl *D);
 
 /// Find the source location of the identifier for \p D.
 /// Transforms macro locations to locations spelled inside files. All code
 /// that needs locations of declaration names (e.g. the index) should go through
 /// this function.
 SourceLocation nameLocation(const clang::Decl &D, const SourceManager &SM);
 
-/// Returns the qualified name of ND. The scope doesn't contain unwritten scopes
-/// like inline namespaces.
-std::string printQualifiedName(const NamedDecl &ND);
-
-/// Returns the first enclosing namespace scope starting from \p DC.
-std::string printNamespaceScope(const DeclContext &DC);
-
 /// Returns the name of the namespace inside the 'using namespace' directive, as
 /// written in the code. E.g., passing 'using namespace ::std' will result in
 /// '::std'.
 std::string printUsingNamespaceName(const ASTContext &Ctx,
                                     const UsingDirectiveDecl &D);
 
 /// Prints unqualified name of the decl for the purpose of displaying it to the
 /// user. Anonymous decls return names of the form "(anonymous {kind})", e.g.

clang-tools-extra/clangd/AST.cpp

 
 SourceLocation nameLocation(const clang::Decl &D, const SourceManager &SM) {
   auto L = D.getLocation();
   if (isSpelledInSource(L, SM))
     return SM.getSpellingLoc(L);
   return SM.getExpansionLoc(L);
 }
 
-std::string printQualifiedName(const NamedDecl &ND) {
-  std::string QName;
-  llvm::raw_string_ostream OS(QName);
-  PrintingPolicy Policy(ND.getASTContext().getLangOpts());
-  // Note that inline namespaces are treated as transparent scopes. This
-  // reflects the way they're most commonly used for lookup. Ideally we'd
-  // include them, but at query time it's hard to find all the inline
-  // namespaces to query: the preamble doesn't have a dedicated list.
-  Policy.SuppressUnwrittenScope = true;
-  ND.printQualifiedName(OS, Policy);
-  OS.flush();
-  assert(!StringRef(QName).startswith("::"));
-  return QName;
-}
-
 static bool isAnonymous(const DeclarationName &N) {
   return N.isIdentifier() && !N.getAsIdentifierInfo();
 }
 
 NestedNameSpecifierLoc getQualifierLoc(const NamedDecl &ND) {
   if (auto *V = llvm::dyn_cast<DeclaratorDecl>(&ND))
     return V->getQualifierLoc();
   if (auto *T = llvm::dyn_cast<TagDecl>(&ND))
if (const TypeSourceInfo *TSI = Cls->getTypeAsWritten()) {
       // location information.
       printTemplateArgumentList(OS, Cls->getTemplateArgs().asArray(), Policy);
     }
   }
   OS.flush();
   return TemplateArgs;
 }
 
-std::string printNamespaceScope(const DeclContext &DC) {
-  for (const auto *Ctx = &DC; Ctx != nullptr; Ctx = Ctx->getParent())
-    if (const auto *NS = dyn_cast<NamespaceDecl>(Ctx))
-      if (!NS->isAnonymousNamespace() && !NS->isInlineNamespace())
-        return printQualifiedName(*NS) + "::";
-  return "";
-}
-
 static llvm::StringRef
 getNameOrErrForObjCInterface(const ObjCInterfaceDecl *ID) {
   return ID ? ID->getName() : "<<error-type>>";
 }
 
 std::string printObjCMethod(const ObjCMethodDecl &Method) {
   std::string Name;
   llvm::raw_string_ostream OS(Name);

clang/include/clang/AST/Decl.h

 
 /// OpenMP variants are mangled early based on their OpenMP context selector.
 /// The new name looks likes this:
 ///  <name> + OpenMPVariantManglingSeparatorStr + <mangled OpenMP context>
 static constexpr StringRef getOpenMPVariantManglingSeparatorStr() {
   return "$ompvariant";
 }
 
+/// Returns the qualified name of ND. The scope doesn't contain unwritten scopes
+/// like inline namespaces.
+std::string printQualifiedName(const NamedDecl &ND);
+
+/// Returns the first enclosing namespace scope starting from \p DC.
+std::string printNamespaceScope(const DeclContext &DC);
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_DECL_H

clang/lib/AST/Decl.cpp

 ExportDecl *ExportDecl::Create(ASTContext &C, DeclContext *DC,
                                SourceLocation ExportLoc) {
   return new (C, DC) ExportDecl(DC, ExportLoc);
 }
 
 ExportDecl *ExportDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) ExportDecl(nullptr, SourceLocation());
 }
+
+//===----------------------------------------------------------------------===//
+// Helpers
+//===----------------------------------------------------------------------===//
+
+std::string clang::printQualifiedName(const NamedDecl &ND) {
+  std::string QName;
+  llvm::raw_string_ostream OS(QName);
+  clang::PrintingPolicy Policy(ND.getASTContext().getLangOpts());
+  // Note that inline namespaces are treated as transparent scopes. This
+  // reflects the way they're most commonly used for lookup. Ideally we'd
+  // include them, but at query time it's hard to find all the inline
+  // namespaces to query: the preamble doesn't have a dedicated list.
+  Policy.SuppressUnwrittenScope = true;
+  ND.printQualifiedName(OS, Policy);
+  OS.flush();
+  assert(!StringRef(QName).startswith("::"));
+  return QName;
+}
+
+/// Returns the first enclosing namespace scope starting from \p DC.
+std::string clang::printNamespaceScope(const DeclContext &DC) {
+  for (const auto *Ctx = &DC; Ctx != nullptr; Ctx = Ctx->getParent())
+    if (const auto *NS = dyn_cast<NamespaceDecl>(Ctx))
+      if (!NS->isAnonymousNamespace() && !NS->isInlineNamespace())
+        return clang::printQualifiedName(*NS) + "::";
+  return "";
+}