clang-tools-extra/clangd/AST.cpp

   1 //===--- AST.cpp - Utility AST functions  -----------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "AST.h"
  10
  11 #include "SourceCode.h"
  12 #include "clang/AST/ASTContext.h"
  13 #include "clang/AST/Decl.h"
  14 #include "clang/AST/DeclTemplate.h"
  15 #include "clang/AST/DeclarationName.h"
  16 #include "clang/AST/NestedNameSpecifier.h"
  17 #include "clang/AST/PrettyPrinter.h"
  18 #include "clang/AST/TemplateBase.h"
  19 #include "clang/Basic/SourceLocation.h"
  20 #include "clang/Basic/SourceManager.h"
  21 #include "clang/Basic/Specifiers.h"
  22 #include "clang/Index/USRGeneration.h"
  23 #include "llvm/ADT/Optional.h"
  24 #include "llvm/Support/Casting.h"
  25 #include "llvm/Support/ScopedPrinter.h"
  26 #include "llvm/Support/raw_ostream.h"
  27
  28 namespace clang {
  29 namespace clangd {
  30
  31 namespace {
  32 llvm::Optional<llvm::ArrayRef<TemplateArgumentLoc>>
  33 getTemplateSpecializationArgLocs(const NamedDecl &ND) {
  34   if (auto *Func = llvm::dyn_cast<FunctionDecl>(&ND)) {
  35     if (const ASTTemplateArgumentListInfo *Args =
  36             Func->getTemplateSpecializationArgsAsWritten())
  37       return Args->arguments();
  38   } else if (auto *Cls =
  39                  llvm::dyn_cast<ClassTemplatePartialSpecializationDecl>(&ND)) {
  40     if (auto *Args = Cls->getTemplateArgsAsWritten())
  41       return Args->arguments();
  42   } else if (auto *Var =
  43                  llvm::dyn_cast<VarTemplatePartialSpecializationDecl>(&ND)) {
  44     if (auto *Args = Var->getTemplateArgsAsWritten())
  45       return Args->arguments();
  46   } else if (auto *Var = llvm::dyn_cast<VarTemplateSpecializationDecl>(&ND))
  47     return Var->getTemplateArgsInfo().arguments();
  48   // We return None for ClassTemplateSpecializationDecls because it does not
  49   // contain TemplateArgumentLoc information.
  50   return llvm::None;
  51 }
  52
  53 template <class T>
  54 bool isTemplateSpecializationKind(const NamedDecl *D,
  55                                   TemplateSpecializationKind Kind) {
  56   if (const auto *TD = dyn_cast<T>(D))
  57     return TD->getTemplateSpecializationKind() == Kind;
  58   return false;
  59 }
  60
  61 bool isTemplateSpecializationKind(const NamedDecl *D,
  62                                   TemplateSpecializationKind Kind) {
  63   return isTemplateSpecializationKind<FunctionDecl>(D, Kind) ||
  64          isTemplateSpecializationKind<CXXRecordDecl>(D, Kind) ||
  65          isTemplateSpecializationKind<VarDecl>(D, Kind);
  66 }
  67
  68 } // namespace
  69
  70 bool isImplicitTemplateInstantiation(const NamedDecl *D) {
  71   return isTemplateSpecializationKind(D, TSK_ImplicitInstantiation);
  72 }
  73
  74 bool isExplicitTemplateSpecialization(const NamedDecl *D) {
  75   return isTemplateSpecializationKind(D, TSK_ExplicitSpecialization);
  76 }
  77
  78 bool isImplementationDetail(const Decl *D) {
  79   return !isSpelledInSource(D->getLocation(),
  80                             D->getASTContext().getSourceManager());
  81 }
  82
  83 SourceLocation findName(const clang::Decl *D) {
  84   return D->getLocation();
  85 }
  86
  87 std::string printQualifiedName(const NamedDecl &ND) {
  88   std::string QName;
  89   llvm::raw_string_ostream OS(QName);
  90   PrintingPolicy Policy(ND.getASTContext().getLangOpts());
  91   // Note that inline namespaces are treated as transparent scopes. This
  92   // reflects the way they're most commonly used for lookup. Ideally we'd
  93   // include them, but at query time it's hard to find all the inline
  94   // namespaces to query: the preamble doesn't have a dedicated list.
  95   Policy.SuppressUnwrittenScope = true;
  96   ND.printQualifiedName(OS, Policy);
  97   OS.flush();
  98   assert(!StringRef(QName).startswith("::"));
  99   return QName;
 100 }
 101
 102 static bool isAnonymous(const DeclarationName &N) {
 103   return N.isIdentifier() && !N.getAsIdentifierInfo();
 104 }
 105
 106 /// Returns a nested name specifier of \p ND if it was present in the source,
 107 /// e.g.
 108 ///     void ns::something::foo() -> returns 'ns::something'
 109 ///     void foo() -> returns null
 110 static NestedNameSpecifier *getQualifier(const NamedDecl &ND) {
 111   if (auto *V = llvm::dyn_cast<DeclaratorDecl>(&ND))
 112     return V->getQualifier();
 113   if (auto *T = llvm::dyn_cast<TagDecl>(&ND))
 114     return T->getQualifier();
 115   return nullptr;
 116 }
 117
 118 std::string printUsingNamespaceName(const ASTContext &Ctx,
 119                                     const UsingDirectiveDecl &D) {
 120   PrintingPolicy PP(Ctx.getLangOpts());
 121   std::string Name;
 122   llvm::raw_string_ostream Out(Name);
 123
 124   if (auto *Qual = D.getQualifier())
 125     Qual->print(Out, PP);
 126   D.getNominatedNamespaceAsWritten()->printName(Out);
 127   return Out.str();
 128 }
 129
 130 std::string printName(const ASTContext &Ctx, const NamedDecl &ND) {
 131   std::string Name;
 132   llvm::raw_string_ostream Out(Name);
 133   PrintingPolicy PP(Ctx.getLangOpts());
 134
 135   // Handle 'using namespace'. They all have the same name - <using-directive>.
 136   if (auto *UD = llvm::dyn_cast<UsingDirectiveDecl>(&ND)) {
 137     Out << "using namespace ";
 138     if (auto *Qual = UD->getQualifier())
 139       Qual->print(Out, PP);
 140     UD->getNominatedNamespaceAsWritten()->printName(Out);
 141     return Out.str();
 142   }
 143
 144   if (isAnonymous(ND.getDeclName())) {
 145     // Come up with a presentation for an anonymous entity.
 146     if (isa<NamespaceDecl>(ND))
 147       return "(anonymous namespace)";
 148     if (auto *Cls = llvm::dyn_cast<RecordDecl>(&ND))
 149       return ("(anonymous " + Cls->getKindName() + ")").str();
 150     if (isa<EnumDecl>(ND))
 151       return "(anonymous enum)";
 152     return "(anonymous)";
 153   }
 154
 155   // Print nested name qualifier if it was written in the source code.
 156   if (auto *Qualifier = getQualifier(ND))
 157     Qualifier->print(Out, PP);
 158   // Print the name itself.
 159   ND.getDeclName().print(Out, PP);
 160   // Print template arguments.
 161   Out << printTemplateSpecializationArgs(ND);
 162
 163   return Out.str();
 164 }
 165
 166 std::string printTemplateSpecializationArgs(const NamedDecl &ND) {
 167   std::string TemplateArgs;
 168   llvm::raw_string_ostream OS(TemplateArgs);
 169   PrintingPolicy Policy(ND.getASTContext().getLangOpts());
 170   if (llvm::Optional<llvm::ArrayRef<TemplateArgumentLoc>> Args =
 171           getTemplateSpecializationArgLocs(ND)) {
 172     printTemplateArgumentList(OS, *Args, Policy);
 173   } else if (auto *Cls = llvm::dyn_cast<ClassTemplateSpecializationDecl>(&ND)) {
 174     if (const TypeSourceInfo *TSI = Cls->getTypeAsWritten()) {
 175       // ClassTemplateSpecializationDecls do not contain
 176       // TemplateArgumentTypeLocs, they only have TemplateArgumentTypes. So we
 177       // create a new argument location list from TypeSourceInfo.
 178       auto STL = TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>();
 179       llvm::SmallVector<TemplateArgumentLoc, 8> ArgLocs;
 180       ArgLocs.reserve(STL.getNumArgs());
 181       for (unsigned I = 0; I < STL.getNumArgs(); ++I)
 182         ArgLocs.push_back(STL.getArgLoc(I));
 183       printTemplateArgumentList(OS, ArgLocs, Policy);
 184     } else {
 185       // FIXME: Fix cases when getTypeAsWritten returns null inside clang AST,
 186       // e.g. friend decls. Currently we fallback to Template Arguments without
 187       // location information.
 188       printTemplateArgumentList(OS, Cls->getTemplateArgs().asArray(), Policy);
 189     }
 190   }
 191   OS.flush();
 192   return TemplateArgs;
 193 }
 194
 195 std::string printNamespaceScope(const DeclContext &DC) {
 196   for (const auto *Ctx = &DC; Ctx != nullptr; Ctx = Ctx->getParent())
 197     if (const auto *NS = dyn_cast<NamespaceDecl>(Ctx))
 198       if (!NS->isAnonymousNamespace() && !NS->isInlineNamespace())
 199         return printQualifiedName(*NS) + "::";
 200   return "";
 201 }
 202
 203 llvm::Optional<SymbolID> getSymbolID(const Decl *D) {
 204   llvm::SmallString<128> USR;
 205   if (index::generateUSRForDecl(D, USR))
 206     return None;
 207   return SymbolID(USR);
 208 }
 209
 210 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
 211                                      const MacroInfo *MI,
 212                                      const SourceManager &SM) {
 213   if (MI == nullptr)
 214     return None;
 215   llvm::SmallString<128> USR;
 216   if (index::generateUSRForMacro(II.getName(), MI->getDefinitionLoc(), SM, USR))
 217     return None;
 218   return SymbolID(USR);
 219 }
 220
 221 std::string shortenNamespace(const llvm::StringRef OriginalName,
 222                              const llvm::StringRef CurrentNamespace) {
 223   llvm::SmallVector<llvm::StringRef, 8> OriginalParts;
 224   llvm::SmallVector<llvm::StringRef, 8> CurrentParts;
 225   llvm::SmallVector<llvm::StringRef, 8> Result;
 226   OriginalName.split(OriginalParts, "::");
 227   CurrentNamespace.split(CurrentParts, "::");
 228   auto MinLength = std::min(CurrentParts.size(), OriginalParts.size());
 229
 230   unsigned DifferentAt = 0;
 231   while (DifferentAt < MinLength &&
 232       CurrentParts[DifferentAt] == OriginalParts[DifferentAt]) {
 233     DifferentAt++;
 234   }
 235
 236   for (unsigned i = DifferentAt; i < OriginalParts.size(); ++i) {
 237     Result.push_back(OriginalParts[i]);
 238   }
 239   return join(Result, "::");
 240 }
 241
 242 std::string printType(const QualType QT, const DeclContext & Context){
 243   PrintingPolicy PP(Context.getParentASTContext().getPrintingPolicy());
 244   PP.SuppressUnwrittenScope = 1;
 245   PP.SuppressTagKeyword = 1;
 246   return shortenNamespace(
 247       QT.getAsString(PP),
 248       printNamespaceScope(Context) );
 249 }
 250
 251
 252 } // namespace clangd
 253 } // namespace clang