sammccall created this revision.
sammccall added a reviewer: kbobyrev.
Herald added subscribers: usaxena95, kadircet, arphaman.
sammccall requested review of this revision.
Herald added subscribers: cfe-commits, MaskRay, ilya-biryukov.
Herald added a project: clang-tools-extra.
There are some limitations here, so this is behind a flag for now (in addition
to the config setting for the overall feature).
- symbols without exactly one associated header aren't handled right
- no macro support
- referencing std::size_t usually doesn't leave any trace in the AST that the
alias in std was used, so we associate with stddef.h instead of cstddef. (An
AST issue not specific to stdlib, but much worse there)
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D114077
Files:
clang-tools-extra/clangd/Headers.cpp
clang-tools-extra/clangd/Headers.h
clang-tools-extra/clangd/IncludeCleaner.cpp
clang-tools-extra/clangd/IncludeCleaner.h
clang-tools-extra/clangd/tool/ClangdMain.cpp
clang-tools-extra/clangd/unittests/HeadersTests.cpp
clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
Index: clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
+++ clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
@@ -8,7 +8,9 @@
#include "Annotations.h"
#include "IncludeCleaner.h"
+#include "SourceCode.h"
#include "TestTU.h"
+#include "llvm/ADT/ScopeExit.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -17,6 +19,8 @@
namespace {
using ::testing::ElementsAre;
+using ::testing::ElementsAreArray;
+using ::testing::Pointee;
using ::testing::UnorderedElementsAre;
std::string guard(llvm::StringRef Code) {
@@ -190,7 +194,7 @@
auto AST = TU.build();
std::vector<Position> Points;
- for (const auto &Loc : findReferencedLocations(AST)) {
+ for (const auto &Loc : findReferencedLocations(AST).User) {
if (AST.getSourceManager().getBufferName(Loc).endswith(
TU.HeaderFilename)) {
Points.push_back(offsetToPosition(
@@ -204,6 +208,81 @@
}
}
+TEST(IncludeCleaner, Stdlib) {
+ // Smoke tests only for finding used symbols/headers.
+ // Details of Decl -> stdlib::Symbol -> stdlib::Headers mapping tested there.
+ auto TU = TestTU::withHeaderCode(R"cpp(
+ namespace std { class error_code {}; }
+ class error_code {};
+ namespace nonstd { class error_code {}; }
+ )cpp");
+ struct {
+ llvm::StringRef Code;
+ std::vector<llvm::StringRef> Symbols;
+ std::vector<llvm::StringRef> Headers;
+ } Tests[] = {
+ {"std::error_code x;", {"std::error_code"}, {"<system_error>"}},
+ {"error_code x;", {}, {}},
+ {"nonstd::error_code x;", {}, {}},
+ };
+
+ for (const auto &Test : Tests) {
+ TU.Code = Test.Code.str();
+ ParsedAST AST = TU.build();
+ std::vector<stdlib::Symbol> WantSyms;
+ for (const auto &SymName : Test.Symbols) {
+ auto QName = splitQualifiedName(SymName);
+ auto Sym = stdlib::Symbol::named(QName.first, QName.second);
+ EXPECT_TRUE(Sym) << SymName;
+ WantSyms.push_back(*Sym);
+ }
+ std::vector<stdlib::Header> WantHeaders;
+ for (const auto &HeaderName : Test.Headers) {
+ auto Header = stdlib::Header::named(HeaderName);
+ EXPECT_TRUE(Header) << HeaderName;
+ WantHeaders.push_back(*Header);
+ }
+
+ ReferencedLocations Locs = findReferencedLocations(AST);
+ EXPECT_THAT(Locs.Stdlib, ElementsAreArray(WantSyms));
+ ReferencedFiles Files = findReferencedFiles(Locs, AST.getSourceManager());
+ EXPECT_THAT(Files.Stdlib, ElementsAreArray(WantHeaders));
+ }
+}
+
+MATCHER_P(WrittenInclusion, Written, "") {
+ if (arg.Written != Written)
+ *result_listener << arg.Written;
+ return arg.Written == Written;
+}
+
+TEST(IncludeCleaner, StdlibUnused) {
+ setIncludeCleanerAnalyzesStdlib(true);
+ auto Cleanup =
+ llvm::make_scope_exit([] { setIncludeCleanerAnalyzesStdlib(false); });
+
+ auto TU = TestTU::withCode(R"cpp(
+ #include <list>
+ #include <queue>
+ std::list<int> x;
+ )cpp");
+ // Layout of std library impl is not relevant.
+ TU.AdditionalFiles["bits"] = R"cpp(
+ #pragma once
+ namespace std {
+ template <typename> class list {};
+ template <typename> class queue {};
+ }
+ )cpp";
+ TU.AdditionalFiles["list"] = "#include <bits>";
+ TU.AdditionalFiles["queue"] = "#include <bits>";
+ TU.ExtraArgs = {"-isystem", testRoot()};
+ auto AST = TU.build();
+
+ auto Unused = computeUnusedIncludes(AST);
+ EXPECT_THAT(Unused, ElementsAre(Pointee(WrittenInclusion("<queue>"))));
+}
+
TEST(IncludeCleaner, GetUnusedHeaders) {
llvm::StringLiteral MainFile = R"cpp(
#include "a.h"
@@ -279,7 +358,7 @@
auto ReferencedFiles = findReferencedFiles(findReferencedLocations(AST), SM);
llvm::StringSet<> ReferencedFileNames;
- for (FileID FID : ReferencedFiles)
+ for (FileID FID : ReferencedFiles.User)
ReferencedFileNames.insert(
SM.getPresumedLoc(SM.getLocForStartOfFile(FID)).getFilename());
// Note we deduped the names as _number_ of <built-in>s is uninteresting.
Index: clang-tools-extra/clangd/unittests/HeadersTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/HeadersTests.cpp
+++ clang-tools-extra/clangd/unittests/HeadersTests.cpp
@@ -20,6 +20,7 @@
#include "llvm/Support/Error.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/Path.h"
+#include "llvm/Support/ScopedPrinter.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -364,6 +365,59 @@
EXPECT_THAT(collectIncludes().MainFileIncludes,
Contains(AllOf(IncludeLine(2), Written("<a.h>"))));
}
+
+TEST(StdlibTest, All) {
+ auto VectorH = stdlib::Header::named("<vector>");
+ EXPECT_TRUE(VectorH);
+ EXPECT_EQ(llvm::to_string(*VectorH), "<vector>");
+ EXPECT_FALSE(stdlib::Header::named("HeadersTests.cpp"));
+
+ auto Vector = stdlib::Symbol::named("std::", "vector");
+ EXPECT_TRUE(Vector);
+ EXPECT_EQ(llvm::to_string(*Vector), "std::vector");
+ EXPECT_FALSE(stdlib::Symbol::named("std::", "dongle"));
+ EXPECT_FALSE(stdlib::Symbol::named("clang::", "ASTContext"));
+
+ EXPECT_EQ(Vector->header(), *VectorH);
+ EXPECT_THAT(Vector->headers(), ElementsAre(*VectorH));
+}
+
+TEST(StdlibTest, Recognizer) {
+ auto TU = TestTU::withCode(R"cpp(
+ namespace std {
+ inline namespace inl {
+
+ template <typename>
+ struct vector { class nested {}; };
+
+ class secret {};
+
+ } // inl
+ } // std
+
+ class vector {};
+ std::vector<int> vec;
+ std::vector<int>::nested nest;
+ std::secret sec;
+ )cpp");
+
+ auto AST = TU.build();
+ auto &vector_nonstd = findDecl(AST, "vector");
+ auto *vec =
+ cast<VarDecl>(findDecl(AST, "vec")).getType()->getAsCXXRecordDecl();
+ auto *nest =
+ cast<VarDecl>(findDecl(AST, "nest")).getType()->getAsCXXRecordDecl();
+ auto *sec =
+ cast<VarDecl>(findDecl(AST, "sec")).getType()->getAsCXXRecordDecl();
+
+ stdlib::Recognizer recognizer;
+
+ EXPECT_EQ(recognizer(&vector_nonstd), llvm::None);
+ EXPECT_EQ(recognizer(vec), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(recognizer(nest), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(recognizer(sec), llvm::None);
+}
+
} // namespace
} // namespace clangd
} // namespace clang
Index: clang-tools-extra/clangd/tool/ClangdMain.cpp
===================================================================
--- clang-tools-extra/clangd/tool/ClangdMain.cpp
+++ clang-tools-extra/clangd/tool/ClangdMain.cpp
@@ -12,6 +12,7 @@
#include "Config.h"
#include "ConfigProvider.h"
#include "Feature.h"
+#include "IncludeCleaner.h"
#include "PathMapping.h"
#include "Protocol.h"
#include "TidyProvider.h"
@@ -251,6 +252,15 @@
"Never insert #include directives as part of code completion")),
};
+opt<bool> IncludeCleanerStdlib{
+ "include-cleaner-stdlib",
+ cat(Features),
+ desc("Apply include-cleaner analysis to standard library headers "
+ "(immature!)"),
+ init(false),
+ Hidden,
+};
+
opt<bool> HeaderInsertionDecorators{
"header-insertion-decorators",
cat(Features),
@@ -932,6 +942,7 @@
};
if (ForceOffsetEncoding != OffsetEncoding::UnsupportedEncoding)
Opts.Encoding = ForceOffsetEncoding;
+ setIncludeCleanerAnalyzesStdlib(IncludeCleanerStdlib);
if (CheckFile.getNumOccurrences()) {
llvm::SmallString<256> Path;
Index: clang-tools-extra/clangd/IncludeCleaner.h
===================================================================
--- clang-tools-extra/clangd/IncludeCleaner.h
+++ clang-tools-extra/clangd/IncludeCleaner.h
@@ -30,7 +30,11 @@
namespace clang {
namespace clangd {
-using ReferencedLocations = llvm::DenseSet<SourceLocation>;
+struct ReferencedLocations {
+ llvm::DenseSet<SourceLocation> User;
+ llvm::DenseSet<stdlib::Symbol> Stdlib;
+};
+
/// Finds locations of all symbols used in the main file.
///
/// - RecursiveASTVisitor finds references to symbols and records their
@@ -48,16 +52,21 @@
/// - err on the side of reporting all possible locations
ReferencedLocations findReferencedLocations(ParsedAST &AST);
+struct ReferencedFiles {
+ llvm::DenseSet<FileID> User;
+ llvm::DenseSet<stdlib::Header> Stdlib;
+};
+
/// Retrieves IDs of all files containing SourceLocations from \p Locs.
/// The output only includes things SourceManager sees as files (not macro IDs).
/// This can include <built-in>, <scratch space> etc that are not true files.
-llvm::DenseSet<FileID> findReferencedFiles(const ReferencedLocations &Locs,
- const SourceManager &SM);
+ReferencedFiles findReferencedFiles(const ReferencedLocations &Locs,
+ const SourceManager &SM);
/// Maps FileIDs to the internal IncludeStructure representation (HeaderIDs).
/// FileIDs that are not true files (<built-in> etc) are dropped.
llvm::DenseSet<IncludeStructure::HeaderID>
-translateToHeaderIDs(const llvm::DenseSet<FileID> &Files,
+translateToHeaderIDs(const ReferencedFiles &Files,
const IncludeStructure &Includes, const SourceManager &SM);
/// Retrieves headers that are referenced from the main file but not used.
@@ -71,6 +80,15 @@
std::vector<Diag> issueUnusedIncludesDiagnostics(ParsedAST &AST,
llvm::StringRef Code);
+/// Affects whether standard library includes should be considered for removal.
+/// This is off by default for now due to implementation limitations:
+/// - macros are not tracked
+/// - symbol names without a unique associated header are not tracked
+/// - references to std-namespaced C types are not properly tracked:
+/// instead of std::size_t -> <cstddef> we see ::size_t -> <stddef.h>
+/// FIXME: remove this hack once the implementation is good enough.
+void setIncludeCleanerAnalyzesStdlib(bool B);
+
} // namespace clangd
} // namespace clang
Index: clang-tools-extra/clangd/IncludeCleaner.cpp
===================================================================
--- clang-tools-extra/clangd/IncludeCleaner.cpp
+++ clang-tools-extra/clangd/IncludeCleaner.cpp
@@ -8,6 +8,7 @@
#include "IncludeCleaner.h"
#include "Config.h"
+#include "Headers.h"
#include "ParsedAST.h"
#include "Protocol.h"
#include "SourceCode.h"
@@ -111,20 +112,23 @@
if (!D || !isNew(D->getCanonicalDecl()))
return;
for (const Decl *Redecl : D->redecls())
- Result.insert(Redecl->getLocation());
+ Result.User.insert(Redecl->getLocation());
+ if (auto SS = StdRecognizer(D))
+ Result.Stdlib.insert(*SS);
}
bool isNew(const void *P) { return P && Visited.insert(P).second; }
ReferencedLocations &Result;
llvm::DenseSet<const void *> Visited;
+ stdlib::Recognizer StdRecognizer;
};
// Given a set of referenced FileIDs, determines all the potentially-referenced
// files and macros by traversing expansion/spelling locations of macro IDs.
// This is used to map the referenced SourceLocations onto real files.
-struct ReferencedFiles {
- ReferencedFiles(const SourceManager &SM) : SM(SM) {}
+struct ReferencedFilesBuilder {
+ ReferencedFilesBuilder(const SourceManager &SM) : SM(SM) {}
llvm::DenseSet<FileID> Files;
llvm::DenseSet<FileID> Macros;
const SourceManager &SM;
@@ -185,18 +189,25 @@
continue;
auto Loc = Macro->Info->getDefinitionLoc();
if (Loc.isValid())
- Result.insert(Loc);
+ Result.User.insert(Loc);
+ // FIXME: support stdlib macros
}
}
-bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST) {
+} // namespace
+
+static bool AnalyzeStdlib;
+void setIncludeCleanerAnalyzesStdlib(bool B) { AnalyzeStdlib = B; }
+
+static bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST) {
// FIXME(kirillbobyrev): We currently do not support the umbrella headers.
- // Standard Library headers are typically umbrella headers, and system
- // headers are likely to be the Standard Library headers. Until we have a
- // good support for umbrella headers and Standard Library headers, don't warn
- // about them.
- if (Inc.Written.front() == '<')
+ // System headers are likely to be standard library headers.
+ // Until we have good support for umbrella headers, don't warn about them.
+ if (Inc.Written.front() == '<') {
+ if (AnalyzeStdlib && stdlib::Header::named(Inc.Written))
+ return true;
return false;
+ }
// Headers without include guards have side effects and are not
// self-contained, skip them.
assert(Inc.HeaderID);
@@ -213,8 +224,6 @@
return true;
}
-} // namespace
-
ReferencedLocations findReferencedLocations(ParsedAST &AST) {
trace::Span Tracer("IncludeCleaner::findReferencedLocations");
ReferencedLocations Result;
@@ -224,22 +233,28 @@
return Result;
}
-llvm::DenseSet<FileID>
-findReferencedFiles(const llvm::DenseSet<SourceLocation> &Locs,
- const SourceManager &SM) {
- std::vector<SourceLocation> Sorted{Locs.begin(), Locs.end()};
+ReferencedFiles findReferencedFiles(const ReferencedLocations &Locs,
+ const SourceManager &SM) {
+ std::vector<SourceLocation> Sorted{Locs.User.begin(), Locs.User.end()};
llvm::sort(Sorted); // Group by FileID.
- ReferencedFiles Result(SM);
+ ReferencedFilesBuilder Builder(SM);
for (auto It = Sorted.begin(); It < Sorted.end();) {
FileID FID = SM.getFileID(*It);
- Result.add(FID, *It);
+ Builder.add(FID, *It);
// Cheaply skip over all the other locations from the same FileID.
// This avoids lots of redundant Loc->File lookups for the same file.
do
++It;
while (It != Sorted.end() && SM.isInFileID(*It, FID));
}
- return std::move(Result.Files);
+ llvm::DenseSet<stdlib::Header> StdlibFiles;
+ for (const auto &Symbol : Locs.Stdlib)
+ for (const auto &Header : Symbol.headers())
+ StdlibFiles.insert(Header);
+ return {
+ std::move(Builder.Files),
+ std::move(StdlibFiles),
+ };
}
std::vector<const Inclusion *>
@@ -273,13 +288,13 @@
#endif
llvm::DenseSet<IncludeStructure::HeaderID>
-translateToHeaderIDs(const llvm::DenseSet<FileID> &Files,
+translateToHeaderIDs(const ReferencedFiles &Files,
const IncludeStructure &Includes,
const SourceManager &SM) {
trace::Span Tracer("IncludeCleaner::translateToHeaderIDs");
llvm::DenseSet<IncludeStructure::HeaderID> TranslatedHeaderIDs;
- TranslatedHeaderIDs.reserve(Files.size());
- for (FileID FID : Files) {
+ TranslatedHeaderIDs.reserve(Files.User.size());
+ for (FileID FID : Files.User) {
const FileEntry *FE = SM.getFileEntryForID(FID);
if (!FE) {
assert(isSpecialBuffer(FID, SM));
@@ -289,6 +304,9 @@
assert(File);
TranslatedHeaderIDs.insert(*File);
}
+ for (stdlib::Header StdlibUsed : Files.Stdlib)
+ for (auto HID : Includes.StdlibHeaders.lookup(StdlibUsed))
+ TranslatedHeaderIDs.insert(HID);
return TranslatedHeaderIDs;
}
Index: clang-tools-extra/clangd/Headers.h
===================================================================
--- clang-tools-extra/clangd/Headers.h
+++ clang-tools-extra/clangd/Headers.h
@@ -29,8 +29,75 @@
#include <string>
namespace clang {
+class NamespaceDecl;
namespace clangd {
+// clangd has a built-in database of standard library symbols.
+namespace stdlib {
+
+// A standard library header, such as <iostream>
+// Lightweight class, in fact just an index into a table.
+class Header {
+public:
+ static llvm::Optional<Header> named(llvm::StringRef);
+
+ friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
+ return OS << H.name();
+ }
+ llvm::StringRef name() const;
+
+private:
+ Header(unsigned ID) : ID(ID) {}
+ unsigned ID;
+ friend class Symbol;
+ friend llvm::DenseMapInfo<Header>;
+ friend bool operator==(const Header &L, const Header &R) {
+ return L.ID == R.ID;
+ }
+};
+
+// A top-level standard library symbol, such as std::vector
+// Lightweight class, in fact just an index into a table.
+class Symbol {
+public:
+ static llvm::Optional<Symbol> named(llvm::StringRef Scope,
+ llvm::StringRef Name);
+
+ friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
+ return OS << S.scope() << S.name();
+ }
+ llvm::StringRef scope() const;
+ llvm::StringRef name() const;
+ Header header() const;
+ llvm::SmallVector<Header> headers() const;
+
+private:
+ Symbol(unsigned ID) : ID(ID) {}
+ unsigned ID;
+ friend class Recognizer;
+ friend llvm::DenseMapInfo<Symbol>;
+ friend bool operator==(const Symbol &L, const Symbol &R) {
+ return L.ID == R.ID;
+ }
+};
+
+// A functor to find the stdlib::Symbol associated with a decl.
+//
+// For non-top-level decls (std::vector<int>::iterator), returns the top-level
+// symbol (std::vector).
+class Recognizer {
+public:
+ Recognizer();
+ llvm::Optional<Symbol> operator()(const Decl *D);
+
+private:
+ using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
+ NSSymbolMap *namespaceSymbols(const NamespaceDecl *D);
+ llvm::DenseMap<const DeclContext *, NSSymbolMap *> NamespaceCache;
+};
+
+} // namespace stdlib
+
/// Returns true if \p Include is literal include like "path" or <path>.
bool isLiteralInclude(llvm::StringRef Include);
@@ -151,6 +218,8 @@
// Maps HeaderID to the ids of the files included from it.
llvm::DenseMap<HeaderID, SmallVector<HeaderID>> IncludeChildren;
+ llvm::DenseMap<stdlib::Header, llvm::SmallVector<HeaderID>> StdlibHeaders;
+
std::vector<Inclusion> MainFileIncludes;
// We reserve HeaderID(0) for the main file and will manually check for that
@@ -256,6 +325,38 @@
}
};
+template <> struct DenseMapInfo<clang::clangd::stdlib::Header> {
+ static inline clang::clangd::stdlib::Header getEmptyKey() {
+ return clang::clangd::stdlib::Header(-1);
+ }
+ static inline clang::clangd::stdlib::Header getTombstoneKey() {
+ return clang::clangd::stdlib::Header(-2);
+ }
+ static unsigned getHashValue(const clang::clangd::stdlib::Header &H) {
+ return hash_value(H.ID);
+ }
+ static bool isEqual(const clang::clangd::stdlib::Header &LHS,
+ const clang::clangd::stdlib::Header &RHS) {
+ return LHS == RHS;
+ }
+};
+
+template <> struct DenseMapInfo<clang::clangd::stdlib::Symbol> {
+ static inline clang::clangd::stdlib::Symbol getEmptyKey() {
+ return clang::clangd::stdlib::Symbol(-1);
+ }
+ static inline clang::clangd::stdlib::Symbol getTombstoneKey() {
+ return clang::clangd::stdlib::Symbol(-2);
+ }
+ static unsigned getHashValue(const clang::clangd::stdlib::Symbol &S) {
+ return hash_value(S.ID);
+ }
+ static bool isEqual(const clang::clangd::stdlib::Symbol &LHS,
+ const clang::clangd::stdlib::Symbol &RHS) {
+ return LHS == RHS;
+ }
+};
+
} // namespace llvm
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERS_H
Index: clang-tools-extra/clangd/Headers.cpp
===================================================================
--- clang-tools-extra/clangd/Headers.cpp
+++ clang-tools-extra/clangd/Headers.cpp
@@ -56,8 +56,17 @@
SM.getLineNumber(SM.getFileID(HashLoc), Inc.HashOffset) - 1;
Inc.FileKind = FileKind;
Inc.Directive = IncludeTok.getIdentifierInfo()->getPPKeywordID();
- if (File)
- Inc.HeaderID = static_cast<unsigned>(Out->getOrCreateID(File));
+ if (File) {
+ IncludeStructure::HeaderID HID = Out->getOrCreateID(File);
+ Inc.HeaderID = static_cast<unsigned>(HID);
+ if (IsAngled)
+ if (auto StdlibHeader = stdlib::Header::named(Inc.Written)) {
+ auto &IDs = Out->StdlibHeaders[*StdlibHeader];
+ // Few physical files for one stdlib header name, linear scan is ok.
+ if (!llvm::is_contained(IDs, HID))
+ IDs.push_back(HID);
+ }
+ }
}
// Record include graph (not just for main-file includes)
@@ -289,5 +298,155 @@
std::tie(RHS.Directive, RHS.FileKind, RHS.HashOffset, RHS.HashLine,
RHS.Resolved, RHS.Written);
}
+
+namespace stdlib {
+static llvm::StringRef *HeaderNames;
+static std::pair<llvm::StringRef, llvm::StringRef> *SymbolNames;
+static unsigned *SymbolHeaderIDs;
+static llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
+// Maps symbol name -> Symbol::ID, within a namespace.
+using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
+static llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols;
+
+static int initialize() {
+ unsigned SymCount = 0;
+#define SYMBOL(Name, NS, Header) ++SymCount;
+#include "CSymbolMap.inc"
+#include "StdSymbolMap.inc"
+#undef SYMBOL
+ SymbolNames = new std::remove_reference_t<decltype(*SymbolNames)>[SymCount];
+ SymbolHeaderIDs =
+ new std::remove_reference_t<decltype(*SymbolHeaderIDs)>[SymCount];
+ NamespaceSymbols = new std::remove_reference_t<decltype(*NamespaceSymbols)>;
+ HeaderIDs = new std::remove_reference_t<decltype(*HeaderIDs)>;
+
+ auto AddNS = [&](llvm::StringRef NS) -> NSSymbolMap & {
+ auto R = NamespaceSymbols->try_emplace(NS, nullptr);
+ if (R.second)
+ R.first->second = new NSSymbolMap();
+ return *R.first->second;
+ };
+
+ auto AddHeader = [&](llvm::StringRef Header) -> unsigned {
+ return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
+ };
+
+ auto Add = [&, SymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
+ llvm::StringRef HeaderName) mutable {
+ if (NS == "None")
+ NS = "";
+
+ SymbolNames[SymIndex] = {NS, Name};
+ SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
+
+ NSSymbolMap &NSSymbols = AddNS(NS);
+ NSSymbols.try_emplace(Name, SymIndex);
+
+ ++SymIndex;
+ };
+#define SYMBOL(Name, NS, Header) Add(#Name, #NS, #Header);
+#include "CSymbolMap.inc"
+#include "StdSymbolMap.inc"
+#undef SYMBOL
+
+ HeaderNames = new llvm::StringRef[HeaderIDs->size()];
+ for (const auto &E : *HeaderIDs)
+ HeaderNames[E.second] = E.first;
+
+ return 0;
+}
+
+static void ensureInitialized() {
+ static int Dummy = initialize();
+ (void)Dummy;
+}
+
+llvm::Optional<Header> Header::named(llvm::StringRef Name) {
+ ensureInitialized();
+ auto It = HeaderIDs->find(Name);
+ if (It == HeaderIDs->end())
+ return llvm::None;
+ return Header(It->second);
+}
+llvm::StringRef Header::name() const { return HeaderNames[ID]; }
+llvm::StringRef Symbol::scope() const { return SymbolNames[ID].first; }
+llvm::StringRef Symbol::name() const { return SymbolNames[ID].second; }
+llvm::Optional<Symbol> Symbol::named(llvm::StringRef Scope,
+ llvm::StringRef Name) {
+ ensureInitialized();
+ if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(Scope)) {
+ auto It = NSSymbols->find(Name);
+ if (It != NSSymbols->end())
+ return Symbol(It->second);
+ }
+ return llvm::None;
+}
+Header Symbol::header() const { return Header(SymbolHeaderIDs[ID]); }
+llvm::SmallVector<Header> Symbol::headers() const {
+ return {header()}; // FIXME: multiple in case of ambiguity
+}
+
+Recognizer::Recognizer() { ensureInitialized(); }
+
+NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
+ auto It = NamespaceCache.find(D);
+ if (It != NamespaceCache.end())
+ return It->second;
+
+ NSSymbolMap *Result = [&]() -> NSSymbolMap * {
+ if (!D) // Nullptr means the global namespace
+ return NamespaceSymbols->lookup("");
+ if (D->isAnonymousNamespace())
+ return nullptr;
+ if (D->isInlineNamespace()) {
+ if (auto *Parent = llvm::dyn_cast_or_null<NamespaceDecl>(D->getParent()))
+ return namespaceSymbols(Parent);
+ return nullptr;
+ }
+ return NamespaceSymbols->lookup(printNamespaceScope(*D));
+ }();
+ NamespaceCache.try_emplace(D, Result);
+ return Result;
+}
+
+llvm::Optional<Symbol> Recognizer::operator()(const Decl *D) {
+ // If D is std::vector::iterator, `vector` is the outer symbol to look up.
+ // We keep all the candidate DCs as some may turn out to be anon enums.
+ // Do this resolution lazily as we may turn out not to have a std namespace.
+ llvm::SmallVector<const DeclContext *> IntermediateDecl;
+ const DeclContext *DC = D->getDeclContext();
+ while (DC && !DC->isNamespace()) {
+ if (NamedDecl::classofKind(DC->getDeclKind()))
+ IntermediateDecl.push_back(DC);
+ DC = DC->getParent();
+ }
+ NSSymbolMap *Symbols = namespaceSymbols(cast_or_null<NamespaceDecl>(DC));
+ if (!Symbols)
+ return llvm::None;
+
+ llvm::StringRef Name = [&]() -> llvm::StringRef {
+ for (const auto *SymDC : llvm::reverse(IntermediateDecl)) {
+ DeclarationName N = cast<NamedDecl>(SymDC)->getDeclName();
+ if (const auto *II = N.getAsIdentifierInfo())
+ return II->getName();
+ if (!N.isEmpty())
+ return ""; // e.g. operator<: give up
+ }
+ if (const auto *ND = llvm::dyn_cast<NamedDecl>(D))
+ if (const auto *II = ND->getIdentifier())
+ return II->getName();
+ return "";
+ }();
+ if (Name.empty())
+ return llvm::None;
+
+ auto It = Symbols->find(Name);
+ if (It == Symbols->end())
+ return llvm::None;
+ return Symbol(It->second);
+}
+
+} // namespace stdlib
+
} // namespace clangd
} // namespace clang
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
