CbC/CbC_llvm: clang-tools-extra/clangd/ParsedAST.cpp comparison

comparison clang-tools-extra/clangd/ParsedAST.cpp @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "ParsedAST.h"
+#include "../clang-tidy/ClangTidyCheck.h"
 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
 #include "../clang-tidy/ClangTidyModuleRegistry.h"
 #include "AST.h"
 #include "Compiler.h"
+#include "Config.h"
 #include "Diagnostics.h"
+#include "FeatureModule.h"
 #include "Headers.h"
+#include "HeuristicResolver.h"
 #include "IncludeFixer.h"
+#include "Preamble.h"
 #include "SourceCode.h"
+#include "TidyProvider.h"
 #include "index/CanonicalIncludes.h"
 #include "index/Index.h"
 #include "support/Logger.h"
 #include "support/Trace.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <memory>
+#include <vector>
 // Force the linker to link in Clang-tidy modules.
 // clangd doesn't support the static analyzer.
 #define CLANG_TIDY_DISABLE_STATIC_ANALYZER_CHECKS
 #include "../clang-tidy/ClangTidyForceLinker.h"
 class ReplayPreamble : private PPCallbacks {
 public:
 // Attach preprocessor hooks such that preamble events will be injected at
 // the appropriate time.
 // Events will be delivered to the *currently registered* PP callbacks.
-static void attach(const IncludeStructure &Includes, CompilerInstance &Clang,
+static void attach(std::vector<Inclusion> Includes, CompilerInstance &Clang,
 const PreambleBounds &PB) {
 auto &PP = Clang.getPreprocessor();
 auto *ExistingCallbacks = PP.getPPCallbacks();
 // No need to replay events if nobody is listening.
 if (!ExistingCallbacks)
 return;
 PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(new ReplayPreamble(
-Includes, ExistingCallbacks, Clang.getSourceManager(), PP,
+std::move(Includes), ExistingCallbacks, Clang.getSourceManager(), PP,
 Clang.getLangOpts(), PB)));
 // We're relying on the fact that addPPCallbacks keeps the old PPCallbacks
 // around, creating a chaining wrapper. Guard against other implementations.
 assert(PP.getPPCallbacks() != ExistingCallbacks &&
 "Expected chaining implementation");
 }
 private:
-ReplayPreamble(const IncludeStructure &Includes, PPCallbacks *Delegate,
+ReplayPreamble(std::vector<Inclusion> Includes, PPCallbacks *Delegate,
 const SourceManager &SM, Preprocessor &PP,
 const LangOptions &LangOpts, const PreambleBounds &PB)
-: Includes(Includes), Delegate(Delegate), SM(SM), PP(PP) {
+: Includes(std::move(Includes)), Delegate(Delegate), SM(SM), PP(PP) {
 // Only tokenize the preamble section of the main file, as we are not
 // interested in the rest of the tokens.
 MainFileTokens = syntax::tokenize(
 syntax::FileRange(SM.getMainFileID(), 0, PB.Size), SM, LangOpts);
 }
 // We insert them right after the built-in header, which still appears.
 void FileChanged(SourceLocation Loc, FileChangeReason Reason,
 SrcMgr::CharacteristicKind Kind, FileID PrevFID) override {
 // It'd be nice if there was a better way to identify built-in headers...
 if (Reason == FileChangeReason::ExitFile &&
-SM.getBuffer(PrevFID)->getBufferIdentifier() == "<built-in>")
+SM.getBufferOrFake(PrevFID).getBufferIdentifier() == "<built-in>")
 replay();
 }
 void replay() {
-for (const auto &Inc : Includes.MainFileIncludes) {
+for (const auto &Inc : Includes) {
-const FileEntry *File = nullptr;
+llvm::Optional<FileEntryRef> File;
 if (Inc.Resolved != "")
-if (auto FE = SM.getFileManager().getFile(Inc.Resolved))
+File = expectedToOptional(SM.getFileManager().getFileRef(Inc.Resolved));
-File = *FE;
 // Re-lex the #include directive to find its interesting parts.
 auto HashLoc = SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
 auto HashTok = llvm::partition_point(MainFileTokens,
 [&HashLoc](const syntax::Token &T) {
 // quotes/angles.
 SynthesizedFilenameTok.setLength(Inc.Written.length());
 SynthesizedFilenameTok.setKind(tok::header_name);
 SynthesizedFilenameTok.setLiteralData(Inc.Written.data());
+const FileEntry *FE = File ? &File->getFileEntry() : nullptr;
 llvm::StringRef WrittenFilename =
 llvm::StringRef(Inc.Written).drop_front().drop_back();
 Delegate->InclusionDirective(HashTok->location(), SynthesizedIncludeTok,
 WrittenFilename, Inc.Written.front() == '<',
-FileTok->range(SM).toCharRange(SM), File,
+FileTok->range(SM).toCharRange(SM), FE,
 "SearchPath", "RelPath",
 /*Imported=*/nullptr, Inc.FileKind);
 if (File)
-// FIXME: Use correctly named FileEntryRef.
+Delegate->FileSkipped(*File, SynthesizedFilenameTok, Inc.FileKind);
-Delegate->FileSkipped(FileEntryRef(File->getName(), *File),
-SynthesizedFilenameTok, Inc.FileKind);
 else {
 llvm::SmallString<1> UnusedRecovery;
 Delegate->FileNotFound(WrittenFilename, UnusedRecovery);
 }
 }
 }
-const IncludeStructure &Includes;
+const std::vector<Inclusion> Includes;
 PPCallbacks *Delegate;
 const SourceManager &SM;
 Preprocessor &PP;
 std::vector<syntax::Token> MainFileTokens;
 };
 } // namespace
-void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS) {
-AST.getASTContext().getTranslationUnitDecl()->dump(OS, true);
-}
 llvm::Optional<ParsedAST>
 ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
 std::unique_ptr<clang::CompilerInvocation> CI,
 llvm::ArrayRef<Diag> CompilerInvocationDiags,
 std::shared_ptr<const PreambleData> Preamble) {
 trace::Span Tracer("BuildAST");
 SPAN_ATTACH(Tracer, "File", Filename);
-auto VFS = Inputs.FS;
+auto VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
 if (Preamble && Preamble->StatCache)
 VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
-if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
-log("Couldn't set working directory when building the preamble.");
-// We proceed anyway, our lit-tests rely on results for non-existing working
-// dirs.
-}
 assert(CI);
 // Command-line parsing sets DisableFree to true by default, but we don't want
 // to leak memory in clangd.
 CI->getFrontendOpts().DisableFree = false;
 // This is on-by-default in windows to allow parsing SDK headers, but it
 // breaks many features. Disable it for the main-file (not preamble).
 CI->getLangOpts()->DelayedTemplateParsing = false;
+std::vector<std::unique_ptr<FeatureModule::ASTListener>> ASTListeners;
+if (Inputs.FeatureModules) {
+for (auto &M : *Inputs.FeatureModules) {
+if (auto Listener = M.astListeners())
+ASTListeners.emplace_back(std::move(Listener));
+}
+}
 StoreDiags ASTDiags;
+ASTDiags.setDiagCallback(
+[&ASTListeners](const clang::Diagnostic &D, clangd::Diag &Diag) {
+llvm::for_each(ASTListeners,
+[&](const auto &L) { L->sawDiagnostic(D, Diag); });
+});
+llvm::Optional<PreamblePatch> Patch;
+bool PreserveDiags = true;
+if (Preamble) {
+Patch = PreamblePatch::create(Filename, Inputs, *Preamble);
+Patch->apply(*CI);
+PreserveDiags = Patch->preserveDiagnostics();
+}
 auto Clang = prepareCompilerInstance(
 std::move(CI), PreamblePCH,
 llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, Filename), VFS,
 ASTDiags);
 if (!Clang)
 std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
 ast_matchers::MatchFinder CTFinder;
 llvm::Optional<tidy::ClangTidyContext> CTContext;
 {
 trace::Span Tracer("ClangTidyInit");
+tidy::ClangTidyOptions ClangTidyOpts =
+getTidyOptionsForFile(Inputs.ClangTidyProvider, Filename);
 dlog("ClangTidy configuration for file {0}: {1}", Filename,
-tidy::configurationAsText(Inputs.Opts.ClangTidyOpts));
+tidy::configurationAsText(ClangTidyOpts));
 tidy::ClangTidyCheckFactories CTFactories;
 for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
 E.instantiate()->addCheckFactories(CTFactories);
 CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
-tidy::ClangTidyGlobalOptions(), Inputs.Opts.ClangTidyOpts));
+tidy::ClangTidyGlobalOptions(), ClangTidyOpts));
 CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
 CTContext->setASTContext(&Clang->getASTContext());
 CTContext->setCurrentFile(Filename);
 CTChecks = CTFactories.createChecks(CTContext.getPointer());
-ASTDiags.setLevelAdjuster([&CTContext](DiagnosticsEngine::Level DiagLevel,
+llvm::erase_if(CTChecks, [&](const auto &Check) {
-const clang::Diagnostic &Info) {
+return !Check->isLanguageVersionSupported(CTContext->getLangOpts());
-if (CTContext) {
+});
+Preprocessor *PP = &Clang->getPreprocessor();
+for (const auto &Check : CTChecks) {
+Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
+Check->registerMatchers(&CTFinder);
+}
+const Config &Cfg = Config::current();
+ASTDiags.setLevelAdjuster([&](DiagnosticsEngine::Level DiagLevel,
+const clang::Diagnostic &Info) {
+if (Cfg.Diagnostics.SuppressAll ||
+isBuiltinDiagnosticSuppressed(Info.getID(), Cfg.Diagnostics.Suppress))
+return DiagnosticsEngine::Ignored;
+if (!CTChecks.empty()) {
 std::string CheckName = CTContext->getCheckName(Info.getID());
 bool IsClangTidyDiag = !CheckName.empty();
 if (IsClangTidyDiag) {
+if (Cfg.Diagnostics.Suppress.contains(CheckName))
+return DiagnosticsEngine::Ignored;
 // Check for suppression comment. Skip the check for diagnostics not
 // in the main file, because we don't want that function to query the
 // source buffer for preamble files. For the same reason, we ask
 // shouldSuppressDiagnostic to avoid I/O.
 // We let suppression comments take precedence over warning-as-error
 }
 }
 }
 return DiagLevel;
 });
-Preprocessor *PP = &Clang->getPreprocessor();
-for (const auto &Check : CTChecks) {
-if (!Check->isLanguageVersionSupported(CTContext->getLangOpts()))
-continue;
-// FIXME: the PP callbacks skip the entire preamble.
-// Checks that want to see #includes in the main file do not see them.
-Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
-Check->registerMatchers(&CTFinder);
-}
 }
 // Add IncludeFixer which can recover diagnostics caused by missing includes
 // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
 llvm::Optional<IncludeFixer> FixIncludes;
 auto BuildDir = VFS->getCurrentWorkingDirectory();
-if (Inputs.Opts.SuggestMissingIncludes && Inputs.Index &&
+if (Inputs.Index && !BuildDir.getError()) {
-!BuildDir.getError()) {
+auto Style = getFormatStyleForFile(Filename, Inputs.Contents, *Inputs.TFS);
-auto Style = getFormatStyleForFile(Filename, Inputs.Contents, VFS.get());
 auto Inserter = std::make_shared<IncludeInserter>(
 Filename, Inputs.Contents, Style, BuildDir.get(),
 &Clang->getPreprocessor().getHeaderSearchInfo());
 if (Preamble) {
 for (const auto &Inc : Preamble->Includes.MainFileIncludes)
 return FixIncludes->fix(DiagLevl, Info);
 });
 Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());
 }
-// Copy over the includes from the preamble, then combine with the
+IncludeStructure Includes;
-// non-preamble includes below.
+// If we are using a preamble, copy existing includes.
-auto Includes = Preamble ? Preamble->Includes : IncludeStructure{};
+if (Preamble) {
-// Replay the preamble includes so that clang-tidy checks can see them.
+Includes = Preamble->Includes;
-if (Preamble)
+Includes.MainFileIncludes = Patch->preambleIncludes();
-ReplayPreamble::attach(Includes, *Clang, Preamble->Preamble.getBounds());
+// Replay the preamble includes so that clang-tidy checks can see them.
+ReplayPreamble::attach(Patch->preambleIncludes(), *Clang,
+Patch->modifiedBounds());
+}
 // Important: collectIncludeStructure is registered *after* ReplayPreamble!
 // Otherwise we would collect the replayed includes again...
 // (We can't *just* use the replayed includes, they don't have Resolved path).
 Clang->getPreprocessor().addPPCallbacks(
 collectIncludeStructureCallback(Clang->getSourceManager(), &Includes));
 // We have to consume the tokens before running clang-tidy to avoid collecting
 // tokens from running the preprocessor inside the checks (only
 // modernize-use-trailing-return-type does that today).
 syntax::TokenBuffer Tokens = std::move(CollectTokens).consume();
+// Makes SelectionTree build much faster.
+Tokens.indexExpandedTokens();
 std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
 // AST traversals should exclude the preamble, to avoid performance cliffs.
 Clang->getASTContext().setTraversalScope(ParsedDecls);
-{
+if (!CTChecks.empty()) {
 // Run the AST-dependent part of the clang-tidy checks.
 // (The preprocessor part ran already, via PPCallbacks).
 trace::Span Tracer("ClangTidyMatch");
 CTFinder.matchAST(Clang->getASTContext());
 }
+// XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.
+// However Action->EndSourceFile() would destroy the ASTContext!
+// So just inform the preprocessor of EOF, while keeping everything alive.
+Clang->getPreprocessor().EndSourceFile();
 // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
 // has a longer lifetime.
 Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
 // CompilerInstance won't run this callback, do it directly.
 ASTDiags.EndSourceFile();
-// XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.
-// However Action->EndSourceFile() would destroy the ASTContext!
+llvm::Optional<std::vector<Diag>> Diags;
-// So just inform the preprocessor of EOF, while keeping everything alive.
+// FIXME: Also skip generation of diagnostics alltogether to speed up ast
-Clang->getPreprocessor().EndSourceFile();
+// builds when we are patching a stale preamble.
+if (PreserveDiags) {
-std::vector<Diag> Diags = CompilerInvocationDiags;
+Diags = CompilerInvocationDiags;
 // Add diagnostics from the preamble, if any.
 if (Preamble)
-Diags.insert(Diags.end(), Preamble->Diags.begin(), Preamble->Diags.end());
+Diags->insert(Diags->end(), Preamble->Diags.begin(),
-// Finally, add diagnostics coming from the AST.
+Preamble->Diags.end());
-{
+// Finally, add diagnostics coming from the AST.
-std::vector<Diag> D = ASTDiags.take(CTContext.getPointer());
+{
-Diags.insert(Diags.end(), D.begin(), D.end());
+std::vector<Diag> D = ASTDiags.take(CTContext.getPointer());
+Diags->insert(Diags->end(), D.begin(), D.end());
+}
 }
 return ParsedAST(Inputs.Version, std::move(Preamble), std::move(Clang),
 std::move(Action), std::move(Tokens), std::move(Macros),
 std::move(ParsedDecls), std::move(Diags),
 std::move(Includes), std::move(CanonIncludes));
 return LocalTopLevelDecls;
 }
 const MainFileMacros &ParsedAST::getMacros() const { return Macros; }
-const std::vector<Diag> &ParsedAST::getDiagnostics() const { return Diags; }
 std::size_t ParsedAST::getUsedBytes() const {
 auto &AST = getASTContext();
 // FIXME(ibiryukov): we do not account for the dynamically allocated part of
 // Message and Fixes inside each diagnostic.
-std::size_t Total =
+std::size_t Total = clangd::getUsedBytes(LocalTopLevelDecls) +
-clangd::getUsedBytes(LocalTopLevelDecls) + clangd::getUsedBytes(Diags);
+(Diags ? clangd::getUsedBytes(*Diags) : 0);
 // FIXME: the rest of the function is almost a direct copy-paste from
 // libclang's clang_getCXTUResourceUsage. We could share the implementation.
 // Sum up various allocators inside the ast context and the preprocessor.
 std::shared_ptr<const PreambleData> Preamble,
 std::unique_ptr<CompilerInstance> Clang,
 std::unique_ptr<FrontendAction> Action,
 syntax::TokenBuffer Tokens, MainFileMacros Macros,
 std::vector<Decl *> LocalTopLevelDecls,
-std::vector<Diag> Diags, IncludeStructure Includes,
+llvm::Optional<std::vector<Diag>> Diags,
-CanonicalIncludes CanonIncludes)
+IncludeStructure Includes, CanonicalIncludes CanonIncludes)
 : Version(Version), Preamble(std::move(Preamble)), Clang(std::move(Clang)),
 Action(std::move(Action)), Tokens(std::move(Tokens)),
 Macros(std::move(Macros)), Diags(std::move(Diags)),
 LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
 Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
+Resolver = std::make_unique<HeuristicResolver>(getASTContext());
 assert(this->Clang);
 assert(this->Action);
 }
+llvm::Optional<llvm::StringRef> ParsedAST::preambleVersion() const {
+if (!Preamble)
+return llvm::None;
+return llvm::StringRef(Preamble->Version);
+}
 } // namespace clangd
 } // namespace clang

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/ParsedAST.cpp @ 221:79ff65ed7e25