10 #include "../clang-tidy/ClangTidyCheck.h"
11 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
12 #include "../clang-tidy/ClangTidyModuleRegistry.h"
30 #include "clang/AST/ASTContext.h"
31 #include "clang/AST/Decl.h"
32 #include "clang/Basic/Diagnostic.h"
33 #include "clang/Basic/DiagnosticSema.h"
34 #include "clang/Basic/LangOptions.h"
35 #include "clang/Basic/SourceLocation.h"
36 #include "clang/Basic/SourceManager.h"
37 #include "clang/Basic/TokenKinds.h"
38 #include "clang/Frontend/CompilerInstance.h"
39 #include "clang/Frontend/CompilerInvocation.h"
40 #include "clang/Frontend/FrontendActions.h"
41 #include "clang/Lex/Lexer.h"
42 #include "clang/Lex/PPCallbacks.h"
43 #include "clang/Lex/Preprocessor.h"
44 #include "clang/Serialization/ASTWriter.h"
45 #include "clang/Tooling/CompilationDatabase.h"
46 #include "clang/Tooling/Syntax/Tokens.h"
47 #include "llvm/ADT/ArrayRef.h"
48 #include "llvm/ADT/STLExtras.h"
49 #include "llvm/ADT/SmallVector.h"
50 #include "llvm/ADT/StringRef.h"
57 #if CLANGD_TIDY_CHECKS
58 #define CLANG_TIDY_DISABLE_STATIC_ANALYZER_CHECKS
59 #include "../clang-tidy/ClangTidyForceLinker.h"
66 template <
class T> std::size_t getUsedBytes(
const std::vector<T> &Vec) {
67 return Vec.capacity() *
sizeof(T);
70 class DeclTrackingASTConsumer :
public ASTConsumer {
72 DeclTrackingASTConsumer(std::vector<Decl *> &TopLevelDecls)
73 : TopLevelDecls(TopLevelDecls) {}
75 bool HandleTopLevelDecl(DeclGroupRef DG)
override {
77 auto &SM =
D->getASTContext().getSourceManager();
80 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(
D))
85 if (isa<ObjCMethodDecl>(
D))
88 TopLevelDecls.push_back(
D);
94 std::vector<Decl *> &TopLevelDecls;
99 std::vector<Decl *> takeTopLevelDecls() {
return std::move(TopLevelDecls); }
102 std::unique_ptr<ASTConsumer>
103 CreateASTConsumer(CompilerInstance &
CI, llvm::StringRef InFile)
override {
104 return std::make_unique<DeclTrackingASTConsumer>( TopLevelDecls);
108 std::vector<Decl *> TopLevelDecls;
122 static void attach(std::vector<Inclusion> Includes, CompilerInstance &
Clang,
123 const PreambleBounds &PB) {
124 auto &PP =
Clang.getPreprocessor();
125 auto *ExistingCallbacks = PP.getPPCallbacks();
127 if (!ExistingCallbacks)
129 PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(
new ReplayPreamble(
130 std::move(Includes), ExistingCallbacks,
Clang.getSourceManager(), PP,
131 Clang.getLangOpts(), PB)));
134 assert(PP.getPPCallbacks() != ExistingCallbacks &&
135 "Expected chaining implementation");
139 ReplayPreamble(std::vector<Inclusion> Includes,
PPCallbacks *Delegate,
140 const SourceManager &SM, Preprocessor &PP,
141 const LangOptions &
LangOpts,
const PreambleBounds &PB)
142 : Includes(std::move(Includes)), Delegate(Delegate), SM(SM), PP(PP) {
145 MainFileTokens = syntax::tokenize(
146 syntax::FileRange(SM.getMainFileID(), 0, PB.Size), SM,
LangOpts);
164 void FileChanged(SourceLocation
Loc, FileChangeReason Reason,
165 SrcMgr::CharacteristicKind
Kind, FileID PrevFID)
override {
167 if (Reason == FileChangeReason::ExitFile &&
168 SM.getBufferOrFake(PrevFID).getBufferIdentifier() ==
"<built-in>")
173 for (
const auto &Inc : Includes) {
174 llvm::Optional<FileEntryRef> File;
175 if (Inc.Resolved !=
"")
176 File = expectedToOptional(SM.getFileManager().getFileRef(Inc.Resolved));
179 auto HashLoc = SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
180 auto HashTok = llvm::partition_point(MainFileTokens,
181 [&HashLoc](
const syntax::Token &T) {
182 return T.location() < HashLoc;
184 assert(HashTok != MainFileTokens.end() && HashTok->kind() == tok::hash);
186 auto IncludeTok = std::next(HashTok);
187 assert(IncludeTok != MainFileTokens.end());
189 auto FileTok = std::next(IncludeTok);
190 assert(FileTok != MainFileTokens.end());
194 Token SynthesizedIncludeTok;
195 SynthesizedIncludeTok.startToken();
196 SynthesizedIncludeTok.setLocation(IncludeTok->location());
197 SynthesizedIncludeTok.setLength(IncludeTok->length());
198 SynthesizedIncludeTok.setKind(tok::raw_identifier);
199 SynthesizedIncludeTok.setRawIdentifierData(IncludeTok->text(SM).data());
200 PP.LookUpIdentifierInfo(SynthesizedIncludeTok);
203 Token SynthesizedFilenameTok;
204 SynthesizedFilenameTok.startToken();
205 SynthesizedFilenameTok.setLocation(FileTok->location());
210 SynthesizedFilenameTok.setLength(Inc.Written.length());
211 SynthesizedFilenameTok.setKind(tok::header_name);
212 SynthesizedFilenameTok.setLiteralData(Inc.Written.data());
214 llvm::StringRef WrittenFilename =
215 llvm::StringRef(Inc.Written).drop_front().drop_back();
216 Delegate->InclusionDirective(
217 HashTok->location(), SynthesizedIncludeTok, WrittenFilename,
218 Inc.Written.front() ==
'<',
219 syntax::FileRange(SM, SynthesizedFilenameTok.getLocation(),
220 SynthesizedFilenameTok.getEndLoc())
222 File,
"SearchPath",
"RelPath",
223 nullptr, Inc.FileKind);
225 Delegate->FileSkipped(*File, SynthesizedFilenameTok, Inc.FileKind);
229 const std::vector<Inclusion> Includes;
231 const SourceManager &SM;
233 std::vector<syntax::Token> MainFileTokens;
244 class TidyDiagnosticGroups {
247 bool Default =
false;
250 llvm::DenseSet<unsigned> Exceptions;
253 TidyDiagnosticGroups(llvm::StringRef
Checks) {
254 constexpr llvm::StringLiteral CDPrefix =
"clang-diagnostic-";
256 llvm::StringRef Check;
262 bool Enable = !Check.consume_front(
"-");
263 bool Glob = Check.consume_back(
"*");
267 if (CDPrefix.startswith(Check)) {
275 if (Default == Enable)
278 if (!Check.consume_front(CDPrefix))
281 if (
auto Group = DiagnosticIDs::getGroupForWarningOption(Check))
282 Exceptions.insert(
static_cast<unsigned>(*Group));
286 bool operator()(diag::Group GroupID)
const {
287 return Exceptions.contains(
static_cast<unsigned>(GroupID)) ? !Default
297 void applyWarningOptions(llvm::ArrayRef<std::string> ExtraArgs,
298 llvm::function_ref<
bool(diag::Group)> EnabledGroups,
299 DiagnosticsEngine &
Diags) {
300 for (llvm::StringRef Group : ExtraArgs) {
303 llvm::SmallVector<diag::kind> Members;
304 if (!Group.consume_front(
"-W") || Group.empty())
306 bool Enable = !Group.consume_front(
"no-");
307 if (
Diags.getDiagnosticIDs()->getDiagnosticsInGroup(
308 diag::Flavor::WarningOrError, Group, Members))
314 bool NeedsWerrorExclusion =
false;
315 for (diag::kind
ID : Members) {
317 if (
Diags.getDiagnosticLevel(
ID, SourceLocation()) <
319 auto Group = DiagnosticIDs::getGroupForDiag(
ID);
320 if (!Group || !EnabledGroups(*Group))
323 if (
Diags.getWarningsAsErrors())
324 NeedsWerrorExclusion =
true;
327 Diags.setSeverity(
ID, diag::Severity::Ignored, SourceLocation());
330 if (NeedsWerrorExclusion) {
334 Diags.setDiagnosticGroupWarningAsError(Group,
false);
341 llvm::Optional<ParsedAST>
343 std::unique_ptr<clang::CompilerInvocation>
CI,
344 llvm::ArrayRef<Diag> CompilerInvocationDiags,
345 std::shared_ptr<const PreambleData> Preamble) {
349 auto VFS =
Inputs.TFS->view(
Inputs.CompileCommand.Directory);
351 VFS =
Preamble->StatCache->getConsumingFS(std::move(VFS));
356 CI->getFrontendOpts().DisableFree =
false;
357 const PrecompiledPreamble *PreamblePCH =
362 CI->getLangOpts()->DelayedTemplateParsing =
false;
364 std::vector<std::unique_ptr<FeatureModule::ASTListener>> ASTListeners;
365 if (
Inputs.FeatureModules) {
366 for (
auto &
M : *
Inputs.FeatureModules) {
367 if (
auto Listener =
M.astListeners())
368 ASTListeners.emplace_back(std::move(Listener));
374 llvm::for_each(ASTListeners,
375 [&](
const auto &L) { L->sawDiagnostic(
D,
Diag); });
378 llvm::Optional<PreamblePatch>
Patch;
379 bool PreserveDiags =
true;
387 PreserveDiags =
Patch->preserveDiagnostics();
389 DiagConsumer = &DropDiags;
392 std::move(
CI), PreamblePCH,
393 llvm::MemoryBuffer::getMemBufferCopy(
Inputs.Contents,
Filename), VFS,
398 std::vector<Diag> Diags(ASTDiags.
take());
399 elog(
"Failed to prepare a compiler instance: {0}",
408 dlog(
"ClangTidy configuration for file {0}: {1}",
Filename,
429 auto &Diags =
Clang->getDiagnostics();
430 TidyDiagnosticGroups TidyGroups(ClangTidyOpts.
Checks ? *ClangTidyOpts.
Checks
431 : llvm::StringRef());
433 applyWarningOptions(*ClangTidyOpts.
ExtraArgsBefore, TidyGroups, Diags);
435 applyWarningOptions(*ClangTidyOpts.
ExtraArgs, TidyGroups, Diags);
438 Clang->getDiagnosticOpts().IgnoreWarnings =
true;
441 auto Action = std::make_unique<ClangdFrontendAction>();
442 const FrontendInputFile &MainInput =
Clang->getFrontendOpts().Inputs[0];
443 if (!Action->BeginSourceFile(*
Clang, MainInput)) {
444 log(
"BeginSourceFile() failed when building AST for {0}",
445 MainInput.getFile());
454 const SourceManager &SM =
Clang->getSourceManager();
455 const FileEntry *MainFE = SM.getFileEntryForID(SM.getMainFileID());
456 Clang->getPreprocessor().getHeaderSearchInfo().MarkFileIncludeOnce(MainFE);
465 std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
466 ast_matchers::MatchFinder CTFinder;
467 llvm::Optional<tidy::ClangTidyContext> CTContext;
468 llvm::Optional<IncludeFixer> FixIncludes;
469 llvm::DenseMap<diag::kind, DiagnosticsEngine::Level> OverriddenSeverity;
475 for (
const auto &
E : tidy::ClangTidyModuleRegistry::entries())
476 E.instantiate()->addCheckFactories(CTFactories);
477 CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
479 CTContext->setDiagnosticsEngine(&
Clang->getDiagnostics());
480 CTContext->setASTContext(&
Clang->getASTContext());
481 CTContext->setCurrentFile(
Filename);
482 CTContext->setSelfContainedDiags(
true);
484 Preprocessor *PP = &
Clang->getPreprocessor();
485 for (
const auto &Check : CTChecks) {
486 Check->registerPPCallbacks(
Clang->getSourceManager(), PP, PP);
487 Check->registerMatchers(&CTFinder);
495 for (
auto ID : {diag::ext_implicit_function_decl_c99,
496 diag::ext_implicit_lib_function_decl_c99,
497 diag::warn_implicit_function_decl}) {
498 OverriddenSeverity.try_emplace(
499 ID,
Clang->getDiagnostics().getDiagnosticLevel(
ID, SourceLocation()));
507 if (Cfg.Diagnostics.SuppressAll ||
509 Clang->getLangOpts()))
510 return DiagnosticsEngine::Ignored;
512 auto It = OverriddenSeverity.find(
Info.getID());
513 if (It != OverriddenSeverity.end())
514 DiagLevel = It->second;
516 if (!CTChecks.empty()) {
517 std::string CheckName = CTContext->getCheckName(Info.getID());
518 bool IsClangTidyDiag = !CheckName.empty();
519 if (IsClangTidyDiag) {
520 if (Cfg.Diagnostics.Suppress.contains(CheckName))
521 return DiagnosticsEngine::Ignored;
528 bool IsInsideMainFile =
529 Info.hasSourceManager() &&
530 isInsideMainFile(Info.getLocation(), Info.getSourceManager());
531 SmallVector<tooling::Diagnostic, 1> TidySuppressedErrors;
532 if (IsInsideMainFile && CTContext->shouldSuppressDiagnostic(
533 DiagLevel, Info, TidySuppressedErrors,
538 return DiagnosticsEngine::Ignored;
542 if (DiagLevel == DiagnosticsEngine::Warning &&
543 CTContext->treatAsError(CheckName)) {
544 return DiagnosticsEngine::Error;
553 auto BuildDir = VFS->getCurrentWorkingDirectory();
554 if (
Inputs.Index && !BuildDir.getError()) {
557 auto Inserter = std::make_shared<IncludeInserter>(
559 &
Clang->getPreprocessor().getHeaderSearchInfo());
561 for (
const auto &Inc :
Preamble->Includes.MainFileIncludes)
562 Inserter->addExisting(Inc);
566 ASTDiags.
contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,
568 return FixIncludes->fix(DiagLevl,
Info);
570 Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());
580 ReplayPreamble::attach(
Patch->preambleIncludes(), *
Clang,
581 Patch->modifiedBounds());
592 Clang->getPreprocessor().addPPCallbacks(
593 std::make_unique<CollectMainFileMacros>(
Clang->getSourceManager(),
596 std::vector<PragmaMark> Marks;
600 Clang->getPreprocessor().addPPCallbacks(
605 CanonicalIncludes CanonIncludes;
610 std::unique_ptr<CommentHandler> IWYUHandler =
612 Clang->getPreprocessor().addCommentHandler(IWYUHandler.get());
615 syntax::TokenCollector CollectTokens(
Clang->getPreprocessor());
620 for (
const auto &L : ASTListeners)
621 L->beforeExecute(*
Clang);
623 if (llvm::Error Err =
Action->Execute())
624 log(
"Execute() failed when building AST for {0}: {1}", MainInput.getFile(),
630 syntax::TokenBuffer Tokens = std::move(CollectTokens).consume();
632 Tokens.indexExpandedTokens();
633 std::vector<Decl *> ParsedDecls =
Action->takeTopLevelDecls();
635 Clang->getASTContext().setTraversalScope(ParsedDecls);
636 if (!CTChecks.empty()) {
639 trace::Span
Tracer(
"ClangTidyMatch");
640 CTFinder.matchAST(
Clang->getASTContext());
646 Clang->getPreprocessor().EndSourceFile();
649 Clang->getDiagnostics().setClient(
new IgnoreDiagnostics);
651 ASTDiags.EndSourceFile();
653 llvm::Optional<std::vector<Diag>>
Diags;
657 Diags = CompilerInvocationDiags;
664 std::vector<Diag>
D = ASTDiags.take(CTContext.getPointer());
669 std::move(
Action), std::move(Tokens), std::move(
Macros),
670 std::move(Marks), std::move(ParsedDecls), std::move(
Diags),
671 std::move(Includes), std::move(CanonIncludes));
673 auto UnusedHeadersDiags =
675 Result.Diags->insert(Result.Diags->end(),
676 make_move_iterator(UnusedHeadersDiags.begin()),
677 make_move_iterator(UnusedHeadersDiags.end()));
682 ParsedAST::ParsedAST(ParsedAST &&Other) =
default;
684 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) =
default;
686 ParsedAST::~ParsedAST() {
690 auto PP =
Clang->getPreprocessorPtr();
691 Clang->setPreprocessor(
nullptr);
697 ASTContext &ParsedAST::getASTContext() {
return Clang->getASTContext(); }
699 const ASTContext &ParsedAST::getASTContext()
const {
700 return Clang->getASTContext();
703 Sema &ParsedAST::getSema() {
return Clang->getSema(); }
705 Preprocessor &ParsedAST::getPreprocessor() {
return Clang->getPreprocessor(); }
707 std::shared_ptr<Preprocessor> ParsedAST::getPreprocessorPtr() {
708 return Clang->getPreprocessorPtr();
711 const Preprocessor &ParsedAST::getPreprocessor()
const {
712 return Clang->getPreprocessor();
715 llvm::ArrayRef<Decl *> ParsedAST::getLocalTopLevelDecls() {
716 return LocalTopLevelDecls;
720 const std::vector<PragmaMark> &ParsedAST::getMarks()
const {
return Marks; }
722 std::size_t ParsedAST::getUsedBytes()
const {
723 auto &AST = getASTContext();
726 std::size_t
Total = clangd::getUsedBytes(LocalTopLevelDecls) +
733 Total += AST.getASTAllocatedMemory();
734 Total += AST.getSideTableAllocatedMemory();
735 Total += AST.Idents.getAllocator().getTotalMemory();
736 Total += AST.Selectors.getTotalMemory();
738 Total += AST.getSourceManager().getContentCacheSize();
739 Total += AST.getSourceManager().getDataStructureSizes();
740 Total += AST.getSourceManager().getMemoryBufferSizes().malloc_bytes;
742 if (ExternalASTSource *Ext = AST.getExternalSource())
743 Total += Ext->getMemoryBufferSizes().malloc_bytes;
745 const Preprocessor &PP = getPreprocessor();
746 Total += PP.getTotalMemory();
747 if (PreprocessingRecord *PRec = PP.getPreprocessingRecord())
748 Total += PRec->getTotalMemory();
749 Total += PP.getHeaderSearchInfo().getTotalMemory();
759 return CanonIncludes;
762 ParsedAST::ParsedAST(llvm::StringRef Version,
763 std::shared_ptr<const PreambleData> Preamble,
764 std::unique_ptr<CompilerInstance>
Clang,
765 std::unique_ptr<FrontendAction>
Action,
767 std::vector<PragmaMark> Marks,
768 std::vector<Decl *> LocalTopLevelDecls,
769 llvm::Optional<std::vector<Diag>>
Diags,
775 LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
776 Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
777 Resolver = std::make_unique<HeuristicResolver>(
getASTContext());
779 assert(this->Action);
785 return llvm::StringRef(
Preamble->Version);