clang-tools-extra/include-cleaner/lib/LocateSymbol.cpp

   1 //===--- LocateSymbol.cpp - Find locations providing a symbol -------------===//
   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 "AnalysisInternal.h"
  10 #include "clang-include-cleaner/Types.h"
  11 #include "clang/AST/Decl.h"
  12 #include "clang/AST/DeclBase.h"
  13 #include "clang/AST/DeclCXX.h"
  14 #include "clang/AST/DeclTemplate.h"
  15 #include "clang/Tooling/Inclusions/StandardLibrary.h"
  16 #include "llvm/Support/Casting.h"
  17 #include <utility>
  18 #include <vector>
  19
  20 namespace clang::include_cleaner {
  21 namespace {
  22
  23 template <typename T> Hints completeIfDefinition(T *D) {
  24   return D->isThisDeclarationADefinition() ? Hints::CompleteSymbol
  25                                            : Hints::None;
  26 }
  27
  28 Hints declHints(const Decl *D) {
  29   // Definition is only needed for classes and templates for completeness.
  30   if (auto *TD = llvm::dyn_cast<TagDecl>(D))
  31     return completeIfDefinition(TD);
  32   else if (auto *CTD = llvm::dyn_cast<ClassTemplateDecl>(D))
  33     return completeIfDefinition(CTD);
  34   else if (auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(D))
  35     return completeIfDefinition(FTD);
  36   // Any other declaration is assumed usable.
  37   return Hints::CompleteSymbol;
  38 }
  39
  40 std::vector<Hinted<SymbolLocation>> locateDecl(const Decl &D) {
  41   std::vector<Hinted<SymbolLocation>> Result;
  42   // FIXME: Should we also provide physical locations?
  43   if (auto SS = tooling::stdlib::Recognizer()(&D))
  44     return {{*SS, Hints::CompleteSymbol}};
  45   // FIXME: Signal foreign decls, e.g. a forward declaration not owned by a
  46   // library. Some useful signals could be derived by checking the DeclContext.
  47   // Most incidental forward decls look like:
  48   //   namespace clang {
  49   //   class SourceManager; // likely an incidental forward decl.
  50   //   namespace my_own_ns {}
  51   //   }
  52   for (auto *Redecl : D.redecls())
  53     Result.push_back({Redecl->getLocation(), declHints(Redecl)});
  54   return Result;
  55 }
  56
  57 std::vector<Hinted<SymbolLocation>> locateMacro(const Macro &M) {
  58   // FIXME: Should we also provide physical locations?
  59   if (auto SS = tooling::stdlib::Symbol::named("", M.Name->getName()))
  60     return {{*SS, Hints::CompleteSymbol}};
  61   return {{M.Definition, Hints::CompleteSymbol}};
  62 }
  63 } // namespace
  64
  65 std::vector<Hinted<SymbolLocation>> locateSymbol(const Symbol &S) {
  66   switch (S.kind()) {
  67   case Symbol::Declaration:
  68     return locateDecl(S.declaration());
  69   case Symbol::Macro:
  70     return locateMacro(S.macro());
  71   }
  72   llvm_unreachable("Unknown Symbol::Kind enum");
  73 }
  74
  75 } // namespace clang::include_cleaner