[clang-tidy] Build it even without static analyzer

[steveire]

Summary

Conditionally compile the parts of clang-tidy which depend on the static
analyzer.

[JonasToth]

Do builds even work properly if the CSA is not build right now?

clang-tidy/tool/CMakeLists.txt

32 ↗

(On Diff #166392)

Is the MPI module remove from the list of available checks (clang-tidy -list-checks) with that?

[steveire]

@JonasToth Sorry, I don't know what's unclear. I'm so surprised by your question that I think maybe I'm missing something. I thought the commit message and the patch itself are clear. Am I missing something?

Currently you can only build clang-tidy if you build the static analyzer.

This patch fixes that so that even if you do not build the static analyzer, you can build clang-tidy. That is the purpose of this patch, as in the title.

Am I missing something? Or did I misunderstand your comment?

clang-tidy/tool/CMakeLists.txt

32 ↗

(On Diff #166392)

Yes.

[lebedev.ri]

#ifdef hell is usually messy and is a source of problems.
May i ask what is the motivation for this change?

[JonasToth]

In D52334#1242811, @steveire wrote:

@JonasToth Sorry, I don't know what's unclear. I'm so surprised by your question that I think maybe I'm missing something. I thought the commit message and the patch itself are clear. Am I missing something?

Currently you can only build clang-tidy if you build the static analyzer.

This patch fixes that so that even if you do not build the static analyzer, you can build clang-tidy. That is the purpose of this patch, as in the title.

Am I missing something? Or did I misunderstand your comment?

Sorry for formulating it unclear. I was curious if you could currently break the clang-tidy builds if you deactivate building CSA and that it might result in some dangling stuff or build errors.
But that clang-tidy is deactivated totally makes that impossible :)

I agree with @lebedev.ri that #ifdef in code might be a problem because its not constantly checked if the build still works if the analyzer is turned off and you might get bitrot.
Some of the clang-tidy stuff relies on Analysis/* from clang as well, e.g. the CFG class. Is this still included in builds with CSA off?

[steveire]

But that clang-tidy is deactivated totally makes that impossible :)

Yes. That should be clear by reading the patch.

Some of the clang-tidy stuff relies on Analysis/* from clang as well, e.g. the CFG class. Is this still included in builds with CSA off?

The Analysis includes are ifdef'd out in the patch. Have you read the patch?

[JonasToth]

Some of the clang-tidy stuff relies on Analysis/* from clang as well, e.g. the CFG class. Is this still included in builds with CSA off?

The Analysis includes are ifdef'd out in the patch. Have you read the patch?

Yes I did read the patch. bugprone-use-after-move utilizes CFG, there is no ifdefing in bugprone module. Thats why I am curious if the CFG is still part of a clang-build if the CSA is deactivated.

EDIT: let me clarify a little, its part of the build, but are there potential consequences, like something is missing ..., in the Analysis directory (because they ifdef something out as well).

[steveire]

Thanks, that at least makes it more obvious where you are getting confused.

See tools/clang/lib/CMakeLists.txt. It contains:

add_subdirectory(Analysis)
# ...
if(CLANG_ENABLE_STATIC_ANALYZER)
  add_subdirectory(StaticAnalyzer)
endif()

1. That is: Analysis and StaticAnalyzer are different.

CLANG_ENABLE_STATIC_ANALYZER refers to the latter.

2. Also, something that may not have occurred to you: This patch does build. Obviously, if there were a problem with CFG after this patch, then it would not build.

Please keep both of those points in mind as you read the patch.

[JonasToth]

In D52334#1242881, @steveire wrote:

Thanks, that at least makes it more obvious where you are getting confused.

See tools/clang/lib/CMakeLists.txt. It contains:

add_subdirectory(Analysis)
# ...
if(CLANG_ENABLE_STATIC_ANALYZER)
  add_subdirectory(StaticAnalyzer)
endif()

1. That is: Analysis and StaticAnalyzer are different.

CLANG_ENABLE_STATIC_ANALYZER refers to the latter.

2. Also, something that may not have occurred to you: This patch does build. Obviously, if there were a problem with CFG after this patch, then it would not build.

Please keep both of those points in mind as you read the patch.

I expected, that you tested a build and running the unit tests as well ;)
What i suspected, that there are other parts directly in C++ source code that do an if CLANG_ENABLE_STATIC_ANALYZER to switch something on/off. I checked that now and it does not seem to be the case.

@alexfh should make the decision as the code-owner, but to me it makes sense to have clang-tidy without CSA.

[steveire]

Handle tests

[steveire]

Actually, I had not run the tests. Thanks for the reminder there. I extended the patch to enable the tests even if CSA is not available.

[alexfh]

! In D52334#1242955, @JonasToth wrote:
... to me it makes sense to have clang-tidy without CSA.

Yep, it seems reasonable.

test/CMakeLists.txt

69 ↗

(On Diff #166644)

There are some clang-tidy tests for the static analyzer integration (at least test/clang-tidy/static-analyzer.cpp and test/clang-tidy/static-analyzer-config.cpp). I would expect them to start failing when clang-tidy is built without static analyzer. Did you try running all the tests?

[steveire]

Enable tests

[steveire]

test/CMakeLists.txt

69 ↗

(On Diff #166644)

I realized that the tests were all excluded by the 'static-analyzer' switch too, so I've enabled them and disabled the ones which require the static-analyzer.

[steveire]

Can I go ahead and merge this now?

[lebedev.ri]

In D52334#1246356, @steveire wrote:

Can I go ahead and merge this now?

In D52334#1242813, @lebedev.ri wrote:

#ifdef hell is usually messy and is a source of problems.
May i ask what is the motivation for this change?

It seems that ^ comment was lost.

[JonasToth]

Please wait for explicit approval from @alexfh

Am 26.09.2018 um 13:05 schrieb Stephen Kelly via Phabricator:

steveire added a comment.

Can I go ahead and merge this now?

Repository:

rCTE Clang Tools Extra

https://reviews.llvm.org/D52334

[JonasToth]

There has been a commit that seems related: https://reviews.llvm.org/rL343168
@steveire could you please take a look at how it affects this patch?

[steveire]

@JonasToth Once again - clangStaticAnalyzerCheckers is not clangAnalysis. Also, that commit changes the mpi plugin, which is excluded by this patch.

[JonasToth]

In D52334#1247809, @steveire wrote:

@JonasToth Once again - clangStaticAnalyzerCheckers is not clangAnalysis. Also, that commit changes the mpi plugin, which is excluded by this patch.

I pinged because of the MPI thing, i did not look further! Sry for noise then.

[aaron.ballman]

I think that we need some sort of developer documentation change that explains 1) that this option exists when configuring clang-tidy, and 2) that this impacts the MPI module as well as the static analyzer.

clang-tidy/CMakeLists.txt

29 ↗

(On Diff #166825)

Indentation looks off here, same below.

clang-tidy/ClangTidy.cpp

93 ↗

(On Diff #166825)

Please add comments to the end of the endif so that it's easier to know what the guarding condition is. Same elsewhere.

[steveire]

Whitespace etc

[steveire]

@aaron.ballman Happy to add a note to the docs, but your request leaves me wondering where?

AFAIK, the fact that clang-tidy wasn't built at all when using CLANG_ENABLE_STATIC_ANALYZER is not documented, so I can't just update that.

Also AFAIK, other build switches don't have such exhaustive documentation that they mention things like this. Is this so important to document that it needs to be done here?

I don't think it is that important. I think it's just a bug that clang-tidy is entirely excluded from the build when not using CLANG_ENABLE_STATIC_ANALYZER. This commit fixes that bug, so it would be great to get a LGTM from someone/anyone so I can commit it.. This patch definitely does not need as much discussion as it is getting. It's just enabling the build of clang-tidy when not building the static analyzer.

clang-tidy/CMakeLists.txt

29 ↗

(On Diff #166825)

Yes, I used the same indentation (none) as the previous code. I can indent this as you wish.

[aaron.ballman]

In D52334#1249875, @steveire wrote:

@aaron.ballman Happy to add a note to the docs, but your request leaves me wondering where?

AFAIK, the fact that clang-tidy wasn't built at all when using CLANG_ENABLE_STATIC_ANALYZER is not documented, so I can't just update that.

I think a reasonable place would be docs/clang-tidy/index.rst in the "Getting Involved" area. We don't currently have any building instructions there, but this at least gets us started with something that may not be obvious to someone trying to get involved in the project.

Also AFAIK, other build switches don't have such exhaustive documentation that they mention things like this. Is this so important to document that it needs to be done here?

We do document these sort of switches in LLVM and Clang (e.g., https://llvm.org/docs/CMake.html). That we don't for extra tools is more a bug than a feature, IMO.

I don't think it is that important. I think it's just a bug that clang-tidy is entirely excluded from the build when not using CLANG_ENABLE_STATIC_ANALYZER. This commit fixes that bug, so it would be great to get a LGTM from someone/anyone so I can commit it.. This patch definitely does not need as much discussion as it is getting. It's just enabling the build of clang-tidy when not building the static analyzer.

It turns out that at least one of the people reviewing your patch disagrees. :-) It's hard to argue that this is fixing a bug when we never documented what you would get in the first place and the status quo is no static analyzer == no clang-tidy. I see this as implementing a new feature: allowing clang-tidy to be built without static analyzer support. Part of new features is documenting them.

I'm sorry that you find this process frustrating. I think the documentation is important here because we have package maintainers that need to know how to build things, and this mysterious undocumented flag changes the behavior of the resulting executable in pretty fundamental ways. It's unfortunate that we didn't document it when it was introduced, and now that we're touching it in interesting ways, we should fix that.

clang-tidy/CMakeLists.txt

29 ↗

(On Diff #166825)

I think it's more clear to indent the body of the if statements, like you've switched to. Someday we should probably figure out cmake-format and try to make use of it to solve this kind of thing.

clang-tidy/plugin/CMakeLists.txt

32–33 ↗

(On Diff #167584)

Indentation.

[steveire]

Docs

[steveire]

I think a reasonable place would be docs/clang-tidy/index.rst in the "Getting Involved" area.

Thanks, that's at least actionable, but not very specific. I've added docs now. If they don't say what you want them to say, then please be specific about what you want them to say. There's no reason to have 5 more rounds of review here if being specific means only one more round is needed.

Are you going to 'accept' this patch eventually, or will I still be waiting for @alexfh once you're happy with it?

[aaron.ballman]

In D52334#1250166, @steveire wrote:

I think a reasonable place would be docs/clang-tidy/index.rst in the "Getting Involved" area.

Thanks, that's at least actionable, but not very specific. I've added docs now. If they don't say what you want them to say, then please be specific about what you want them to say. There's no reason to have 5 more rounds of review here if being specific means only one more round is needed.

It's a reasonable, if terse, start to documenting how to build clang-tidy. Mostly some mechanical changes to format the new docs the same as the other docs in the file.

Are you going to 'accept' this patch eventually, or will I still be waiting for @alexfh once you're happy with it?

Once I'm happy, I will accept it. If @alexfh has further comments, then they can be addressed at that time (pre or post commit).

docs/clang-tidy/index.rst

340–341 ↗

(On Diff #167615)

Double backticks around CLANG_ENABLE_STATIC_ANALYZER
Change "clang tidy" into :program:clang-tidy (with single backticks around clang-tidy)
Change static-analyzer into clang-analyzer-* with double backticks
Change mpi into mpi-* with double backticks

will not have -> will not be built with support for

[steveire]

Format docs

[steveire]

Doc fix

[steveire]

Once I'm happy, I will accept it. If @alexfh has further comments, then they can be addressed at that time (pre or post commit).

That's very reasonable, thanks.

[aaron.ballman]

LGTM! If you need this merged on your behalf, I can do so tomorrow or Monday, unless someone else gets to it first.

[aaron.ballman]

I've commit as r343415, thank you for the patch!

[aaron.ballman]

In D52334#1250439, @aaron.ballman wrote:

I've commit as r343415, thank you for the patch!

I've reverted in r343418 as the commit broke some bots.

http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/builds/37336
http://lab.llvm.org:8011/builders/clang-ppc64be-linux/builds/24630

I also see that you have your own commit access, so I'll let you handle fixing up the failing tests and recommit. If there are not substantial changes required to fix the issue (e.g., it's just a matter of fixing up some tests), you're fine to fix them and commit without further review.

[steveire]

I'll take care of it in a few days and commit it myself. Thanks!

clang-tools-extra/trunk/CMakeLists.txt

 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-reorder-fields)
 add_subdirectory(modularize)
-if(CLANG_ENABLE_STATIC_ANALYZER)
 add_subdirectory(clang-tidy)
 add_subdirectory(clang-tidy-vs)
-endif()
 
 add_subdirectory(change-namespace)
 add_subdirectory(clang-doc)
 add_subdirectory(clang-query)
 add_subdirectory(clang-move)
 add_subdirectory(clangd)
 add_subdirectory(include-fixer)
 add_subdirectory(pp-trace)

clang-tools-extra/trunk/clang-tidy/CMakeLists.txt

add_clang_library(clangTidy
   clangAST
   clangASTMatchers
   clangBasic
   clangFormat
   clangFrontend
   clangLex
   clangRewrite
   clangSema
-  clangStaticAnalyzerCore
-  clangStaticAnalyzerFrontend
   clangTooling
   clangToolingCore
   )
 
+if(CLANG_ENABLE_STATIC_ANALYZER)
+  target_link_libraries(clangTidy PRIVATE
+    clangStaticAnalyzerCore
+    clangStaticAnalyzerFrontend
+  )
+endif()
+
 add_subdirectory(android)
 add_subdirectory(abseil)
 add_subdirectory(boost)
 add_subdirectory(bugprone)
 add_subdirectory(cert)
 add_subdirectory(cppcoreguidelines)
 add_subdirectory(fuchsia)
 add_subdirectory(google)
 add_subdirectory(hicpp)
 add_subdirectory(llvm)
 add_subdirectory(misc)
 add_subdirectory(modernize)
+if(CLANG_ENABLE_STATIC_ANALYZER)
   add_subdirectory(mpi)
+endif()
 add_subdirectory(objc)
 add_subdirectory(performance)
 add_subdirectory(plugin)
 add_subdirectory(portability)
 add_subdirectory(readability)
 add_subdirectory(tool)
 add_subdirectory(utils)
 add_subdirectory(zircon)

clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp

 #include "ClangTidy.h"
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyModuleRegistry.h"
 #include "ClangTidyProfiling.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Config/config.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
+#if CLANG_ENABLE_STATIC_ANALYZER
 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
+#endif // CLANG_ENABLE_STATIC_ANALYZER
 #include "clang/Tooling/DiagnosticsYaml.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <algorithm>
 #include <utility>
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry)
 
 namespace clang {
 namespace tidy {
 
 namespace {
+#if CLANG_ENABLE_STATIC_ANALYZER
 static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
 
 class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
 public:
   AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
 
   void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
                             FilesMade *filesMade) override {
public:
 
   StringRef getName() const override { return "ClangTidyDiags"; }
   bool supportsLogicalOpControlFlow() const override { return true; }
   bool supportsCrossFileDiagnostics() const override { return true; }
 
 private:
   ClangTidyContext &Context;
 };
+#endif // CLANG_ENABLE_STATIC_ANALYZER
 
 class ErrorReporter {
 public:
   ErrorReporter(ClangTidyContext &Context, bool ApplyFixes,
                 llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS)
       : Files(FileSystemOptions(), BaseFS), DiagOpts(new DiagnosticOptions()),
         DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
         Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                          E = ClangTidyModuleRegistry::end();
        I != E; ++I) {
     std::unique_ptr<ClangTidyModule> Module(I->instantiate());
     Module->addCheckFactories(*CheckFactories);
   }
 }
 
+#if CLANG_ENABLE_STATIC_ANALYZER
 static void setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
                                          AnalyzerOptionsRef AnalyzerOptions) {
   StringRef AnalyzerPrefix(AnalyzerCheckNamePrefix);
   for (const auto &Opt : Opts.CheckOptions) {
     StringRef OptName(Opt.first);
     if (!OptName.startswith(AnalyzerPrefix))
       continue;
     AnalyzerOptions->Config[OptName.substr(AnalyzerPrefix.size())] = Opt.second;
for (StringRef CheckName : RegisteredCheckers) {
 
     if (CheckName.startswith("core") ||
         Context.isCheckEnabled(ClangTidyCheckName)) {
       List.emplace_back(CheckName, true);
     }
   }
   return List;
 }
+#endif // CLANG_ENABLE_STATIC_ANALYZER
 
 std::unique_ptr<clang::ASTConsumer>
 ClangTidyASTConsumerFactory::CreateASTConsumer(
     clang::CompilerInstance &Compiler, StringRef File) {
   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
   // modify Compiler.
   Context.setSourceManager(&Compiler.getSourceManager());
   Context.setCurrentFile(File);
for (auto &Check : Checks) {
     Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(Compiler);
   }
 
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
   if (!Checks.empty())
     Consumers.push_back(Finder->newASTConsumer());
 
+#if CLANG_ENABLE_STATIC_ANALYZER
   AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
   AnalyzerOptions->CheckersControlList =
       getCheckersControlList(Context, Context.canEnableAnalyzerAlphaCheckers());
   if (!AnalyzerOptions->CheckersControlList.empty()) {
     setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
     AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
     AnalyzerOptions->AnalyzeNestedBlocks = true;
     AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
     std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
         ento::CreateAnalysisConsumer(Compiler);
     AnalysisConsumer->AddDiagnosticConsumer(
         new AnalyzerDiagnosticConsumer(Context));
     Consumers.push_back(std::move(AnalysisConsumer));
   }
+#endif // CLANG_ENABLE_STATIC_ANALYZER
   return llvm::make_unique<ClangTidyASTConsumer>(
       std::move(Consumers), std::move(Profiling), std::move(Finder),
       std::move(Checks));
 }
 
 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
   std::vector<std::string> CheckNames;
   for (const auto &CheckFactory : *CheckFactories) {
     if (Context.isCheckEnabled(CheckFactory.first))
       CheckNames.push_back(CheckFactory.first);
   }
 
+#if CLANG_ENABLE_STATIC_ANALYZER
   for (const auto &AnalyzerCheck : getCheckersControlList(
            Context, Context.canEnableAnalyzerAlphaCheckers()))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
+#endif // CLANG_ENABLE_STATIC_ANALYZER
 
   std::sort(CheckNames.begin(), CheckNames.end());
   return CheckNames;
 }
 
 ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
   ClangTidyOptions::OptionMap Options;
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;

clang-tools-extra/trunk/clang-tidy/plugin/CMakeLists.txt

add_clang_library(clangTidyPlugin
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
   clangTidyFuchsiaModule
   clangTidyGoogleModule
   clangTidyHICPPModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
-  clangTidyMPIModule
   clangTidyObjCModule
   clangTidyPerformanceModule
   clangTidyPortabilityModule
   clangTidyReadabilityModule
   clangTidyZirconModule
   clangTooling
   )
+
+if(CLANG_ENABLE_STATIC_ANALYZER)
+  target_link_libraries(clangTidyPlugin PRIVATE
+    clangTidyMPIModule
+  )
+endif()

clang-tools-extra/trunk/clang-tidy/plugin/ClangTidyPlugin.cpp

 //===- ClangTidyPlugin.cpp - clang-tidy as a clang plugin -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
+#include "clang/Config/config.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 
 namespace clang {
 namespace tidy {
 
 /// The core clang tidy plugin action. This just provides the AST consumer and

 static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination =
     MiscModuleAnchorSource;
 
 // This anchor is used to force the linker to link the ModernizeModule.
 extern volatile int ModernizeModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
     ModernizeModuleAnchorSource;
 
+#if CLANG_ENABLE_STATIC_ANALYZER
 // This anchor is used to force the linker to link the MPIModule.
 extern volatile int MPIModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
     MPIModuleAnchorSource;
+#endif
 
 // This anchor is used to force the linker to link the ObjCModule.
 extern volatile int ObjCModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ObjCModuleAnchorDestination =
     ObjCModuleAnchorSource;
 
 // This anchor is used to force the linker to link the PerformanceModule.
 extern volatile int PerformanceModuleAnchorSource;

clang-tools-extra/trunk/clang-tidy/tool/CMakeLists.txt

target_link_libraries(clang-tidy
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
   clangTidyFuchsiaModule
   clangTidyGoogleModule
   clangTidyHICPPModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
-  clangTidyMPIModule
   clangTidyObjCModule
   clangTidyPerformanceModule
   clangTidyPortabilityModule
   clangTidyReadabilityModule
   clangTidyZirconModule
   clangTooling
   clangToolingCore
   )
 
+if(CLANG_ENABLE_STATIC_ANALYZER)
+  target_link_libraries(clang-tidy PRIVATE
+    clangTidyMPIModule
+  )
+endif()
+
 install(PROGRAMS clang-tidy-diff.py
   DESTINATION share/clang
   COMPONENT clang-tidy)
 install(PROGRAMS run-clang-tidy.py
   DESTINATION share/clang
   COMPONENT clang-tidy)

clang-tools-extra/trunk/clang-tidy/tool/ClangTidyMain.cpp

 ///
 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
+#include "clang/Config/config.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;

 static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination =
     MiscModuleAnchorSource;
 
 // This anchor is used to force the linker to link the ModernizeModule.
 extern volatile int ModernizeModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
     ModernizeModuleAnchorSource;
 
+#if CLANG_ENABLE_STATIC_ANALYZER
 // This anchor is used to force the linker to link the MPIModule.
 extern volatile int MPIModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
     MPIModuleAnchorSource;
+#endif
 
 // This anchor is used to force the linker to link the PerformanceModule.
 extern volatile int PerformanceModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination =
     PerformanceModuleAnchorSource;
 
 // This anchor is used to force the linker to link the PortabilityModule.
 extern volatile int PortabilityModuleAnchorSource;

clang-tools-extra/trunk/docs/clang-tidy/index.rst

* ``add_new_check.py`` is a script to automate the process of adding a new
     check, it will create the check, update the CMake file and create a test;
   * ``rename_check.py`` does what the script name suggests, renames an existing
     check;
   * :program:`clang-query` is invaluable for interactive prototyping of AST
     matchers and exploration of the Clang AST;
   * `clang-check`_ with the ``-ast-dump`` (and optionally ``-ast-dump-filter``)
     provides a convenient way to dump AST of a C++ program.
 
+If CMake is configured with ``CLANG_ENABLE_STATIC_ANALYZER``,
+:program:`clang-tidy` will not be built with support for the 
+``clang-analyzer-*`` checks or the ``mpi-*`` checks.
+
 
 .. _AST Matchers: http://clang.llvm.org/docs/LibASTMatchers.html
 .. _PPCallbacks: http://clang.llvm.org/doxygen/classclang_1_1PPCallbacks.html
 .. _clang-check: http://clang.llvm.org/docs/ClangCheck.html
 
 
 Choosing the Right Place for your Check
 ---------------------------------------

clang-tools-extra/trunk/test/CMakeLists.txt

set(CLANG_TOOLS_TEST_DEPS
   find-all-symbols
   modularize
   pp-trace
 
   check-clangd
 
   # Unit tests
   ExtraToolsUnitTests
-  )
 
-if(CLANG_ENABLE_STATIC_ANALYZER)
-  list(APPEND CLANG_TOOLS_TEST_DEPS
-    # For the clang-tidy libclang integration test.
-    c-index-test
-    # clang-tidy tests require it.
-    clang-headers
 
-    clang-tidy
-    )
-endif()
 
 add_lit_testsuite(check-clang-tools "Running the Clang extra tools' regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${CLANG_TOOLS_TEST_DEPS}
   ARGS ${CLANG_TOOLS_TEST_EXTRA_ARGS}
   )
 
 set_target_properties(check-clang-tools PROPERTIES FOLDER "Clang extra tools' tests")

clang-tools-extra/trunk/test/clang-tidy/enable-alpha-checks.cpp

+// REQUIRES: static-analyzer
+
 // Check if '-allow-enabling-analyzer-alpha-checkers' is visible for users.
 // RUN: clang-tidy -help | not grep 'allow-enabling-analyzer-alpha-checkers'
 
 // Check if '-allow-enabling-analyzer-alpha-checkers' enables alpha checks.
 // RUN: clang-tidy -checks=* -list-checks | not grep 'clang-analyzer-alpha'
 // RUN: clang-tidy -checks=* -list-checks -allow-enabling-analyzer-alpha-checkers | grep 'clang-analyzer-alpha'

clang-tools-extra/trunk/test/clang-tidy/mpi-buffer-deref.cpp

+// REQUIRES: static-analyzer
 // RUN: %check_clang_tidy %s mpi-buffer-deref %t -- -- -I %S/Inputs/mpi-type-mismatch
 
 #include "mpimock.h"
 
 void negativeTests() {
   char *buf;
   MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer is insufficiently dereferenced: pointer->pointer [mpi-buffer-deref]

clang-tools-extra/trunk/test/clang-tidy/mpi-type-mismatch.cpp

+// REQUIRES: static-analyzer
 // RUN: %check_clang_tidy %s mpi-type-mismatch %t -- -- -I %S/Inputs/mpi-type-mismatch
 
 #include "mpimock.h"
 
 void charNegativeTest() {
   int buf;
   MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int' does not match the MPI datatype 'MPI_CHAR'

clang-tools-extra/trunk/test/clang-tidy/nolint.cpp

+// REQUIRES: static-analyzer
 // RUN: %check_clang_tidy %s google-explicit-constructor,clang-diagnostic-unused-variable,clang-analyzer-core.UndefinedBinaryOperatorResult %t -- -extra-arg=-Wunused-variable -- -I%S/Inputs/nolint
 
 #include "trigger_warning.h"
 void I(int& Out) {
   int In;
   A1(In, Out);
 }
 // CHECK-MESSAGES-NOT: trigger_warning.h:{{.*}} warning

clang-tools-extra/trunk/test/clang-tidy/read_file_config.cpp

+// REQUIRES: static-analyzer
 // RUN: mkdir -p %T/read-file-config/
 // RUN: cp %s %T/read-file-config/test.cpp
 // RUN: echo 'Checks: "-*,modernize-use-nullptr"' > %T/read-file-config/.clang-tidy
 // RUN: echo '[{"command": "cc -c -o test.o test.cpp", "directory": "%/T/read-file-config", "file": "%/T/read-file-config/test.cpp"}]' > %T/read-file-config/compile_commands.json
 // RUN: clang-tidy %T/read-file-config/test.cpp | not grep "warning: .*\[clang-analyzer-deadcode.DeadStores\]$"
 // RUN: clang-tidy -checks="-*,clang-analyzer-*" %T/read-file-config/test.cpp | grep "warning: .*\[clang-analyzer-deadcode.DeadStores\]$"
 
 void f() {
   int x;
   x = 1;
   x = 2;
 }

clang-tools-extra/trunk/test/clang-tidy/static-analyzer-config.cpp

+// REQUIRES: static-analyzer
 // RUN: clang-tidy %s -checks='-*,clang-analyzer-unix.Malloc' -config='{CheckOptions: [{ key: "clang-analyzer-unix.Malloc:Optimistic", value: true}]}' -- | FileCheck %s
 typedef __typeof(sizeof(int)) size_t;
 void *malloc(size_t);
 void free(void *);
 void __attribute((ownership_returns(malloc))) *my_malloc(size_t);
 void __attribute((ownership_takes(malloc, 1))) my_free(void *);
 
 void f1() {

clang-tools-extra/trunk/test/clang-tidy/static-analyzer.cpp

+// REQUIRES: static-analyzer
 // RUN: clang-tidy %s -checks='-*,clang-analyzer-*' -- | FileCheck %s
 extern void *malloc(unsigned long);
 extern void free(void *);
 
 void f() {
   int *p = new int(42);
   delete p;
   delete p;

clang-tools-extra/trunk/test/clang-tidy/temporaries.cpp

+// REQUIRES: static-analyzer
 // RUN: clang-tidy -checks='-*,clang-analyzer-core.NullDereference' %s -- | FileCheck %s
 
 struct NoReturnDtor {
   ~NoReturnDtor() __attribute__((noreturn));
 };
 
 extern bool check(const NoReturnDtor &);
 

clang-tools-extra/trunk/test/lit.cfg

if not platform.system() in ['Windows'] or not execute_external:
     config.available_features.add('shell-preserves-root')
 
 # ANSI escape sequences in non-dumb terminal
 if platform.system() not in ['Windows']:
     config.available_features.add('ansi-escape-sequences')
 
 if config.clang_staticanalyzer:
     config.available_features.add('static-analyzer')
-    check_clang_tidy = os.path.join(
-        config.test_source_root, "clang-tidy", "check_clang_tidy.py")
-    config.substitutions.append(
-        ('%check_clang_tidy',
-         '%s %s' % (config.python_executable, check_clang_tidy)) )
-    clang_tidy_diff = os.path.join(
-        config.test_source_root, "..", "clang-tidy", "tool", "clang-tidy-diff.py")
-    config.substitutions.append(
-        ('%clang_tidy_diff',
-         '%s %s' % (config.python_executable, clang_tidy_diff)) )
-    run_clang_tidy = os.path.join(
-        config.test_source_root, "..", "clang-tidy", "tool", "run-clang-tidy.py")
-    config.substitutions.append(
-        ('%run_clang_tidy',
-         '%s %s' % (config.python_executable, run_clang_tidy)) )
-else:
-    # exclude the clang-tidy test directory
-    config.excludes.append('clang-tidy')
+
 
 clangd_benchmarks_dir = os.path.join(os.path.dirname(config.clang_tools_dir),
                                      "tools", "clang", "tools", "extra",
                                      "clangd", "benchmarks")
 config.substitutions.append(('%clangd-benchmark-dir',
                              '%s' % (clangd_benchmarks_dir)))

clang-tools-extra/trunk/unittests/CMakeLists.txt

add_subdirectory(${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
       lib/Testing/Support)
   endif()
 endif()
 
 add_subdirectory(change-namespace)
 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-move)
 add_subdirectory(clang-query)
-if(CLANG_ENABLE_STATIC_ANALYZER)
-  add_subdirectory(clang-tidy)
-endif()
 add_subdirectory(clangd)
 add_subdirectory(include-fixer)