Disable several more clang-tidy modernize checkers when not compiling in C++ mode. Loop conversion would make recommendations for C code, so added a test to ensure that does not happen. The pass by value, use auto and replace auto_ptr checkers would not make recommendations for C code, and are disabled for performance reasons, but do not require an extra test.

llvm-svn: 246310

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

@@ -539,9 +539,14 @@ void LoopConvertCheck::findAndVerifyUsages(
 }
 
 void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(makeArrayLoopMatcher(), this);
-  Finder->addMatcher(makeIteratorLoopMatcher(), this);
-  Finder->addMatcher(makePseudoArrayLoopMatcher(), this);
+  // Only register the matchers for C++. Because this checker is used for
+  // modernization, it is reasonable to run it on any C++ standard with the
+  // assumption the user is trying to modernize their codebase.
+  if (getLangOpts().CPlusPlus) {
+    Finder->addMatcher(makeArrayLoopMatcher(), this);
+    Finder->addMatcher(makeIteratorLoopMatcher(), this);
+    Finder->addMatcher(makePseudoArrayLoopMatcher(), this);
+  }
 }
 
 void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

@@ -127,35 +127,46 @@ void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 }
 
 void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      constructorDecl(
-          forEachConstructorInitializer(
-              ctorInitializer(
-                  // Clang builds a CXXConstructExpr only whin it knows which
-                  // constructor will be called. In dependent contexts a
-                  // ParenListExpr is generated instead of a CXXConstructExpr,
-                  // filtering out templates automatically for us.
-                  withInitializer(constructExpr(
-                      has(declRefExpr(to(
-                          parmVarDecl(
-                              hasType(qualType(
-                                  // Match only const-ref or a non-const value
-                                  // parameters. Rvalues and const-values
-                                  // shouldn't be modified.
-                                  anyOf(constRefType(), nonConstValueType()))))
-                              .bind("Param")))),
-                      hasDeclaration(constructorDecl(
-                          isCopyConstructor(), unless(isDeleted()),
-                          hasDeclContext(recordDecl(isMoveConstructible())))))))
-                  .bind("Initializer")))
-          .bind("Ctor"),
-      this);
+  // Only register the matchers for C++; the functionality currently does not
+  // provide any benefit to other languages, despite being benign.
+  if (getLangOpts().CPlusPlus) {
+    Finder->addMatcher(
+        constructorDecl(
+            forEachConstructorInitializer(
+                ctorInitializer(
+                    // Clang builds a CXXConstructExpr only whin it knows which
+                    // constructor will be called. In dependent contexts a
+                    // ParenListExpr is generated instead of a CXXConstructExpr,
+                    // filtering out templates automatically for us.
+                    withInitializer(constructExpr(
+                        has(declRefExpr(to(
+                            parmVarDecl(
+                                hasType(qualType(
+                                    // Match only const-ref or a non-const value
+                                    // parameters. Rvalues and const-values
+                                    // shouldn't be modified.
+                                    anyOf(constRefType(),
+                                          nonConstValueType()))))
+                                .bind("Param")))),
+                        hasDeclaration(constructorDecl(
+                            isCopyConstructor(), unless(isDeleted()),
+                            hasDeclContext(
+                                recordDecl(isMoveConstructible())))))))
+                    .bind("Initializer")))
+            .bind("Ctor"),
+        this);
+  }
 }
 
 void PassByValueCheck::registerPPCallbacks(CompilerInstance &Compiler) {
-  Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                     Compiler.getLangOpts(), IncludeStyle));
-  Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
+  // Only register the preprocessor callbacks for C++; the functionality
+  // currently does not provide any benefit to other languages, despite being
+  // benign.
+  if (getLangOpts().CPlusPlus) {
+    Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
+                                       Compiler.getLangOpts(), IncludeStyle));
+    Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
+  }
 }
 
 void PassByValueCheck::check(const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

@@ -198,15 +198,24 @@ void ReplaceAutoPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 }
 
 void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(makeAutoPtrTypeLocMatcher(), this);
-  Finder->addMatcher(makeAutoPtrUsingDeclMatcher(), this);
-  Finder->addMatcher(makeTransferOwnershipExprMatcher(), this);
+  // Only register the matchers for C++; the functionality currently does not
+  // provide any benefit to other languages, despite being benign.
+  if (getLangOpts().CPlusPlus) {
+    Finder->addMatcher(makeAutoPtrTypeLocMatcher(), this);
+    Finder->addMatcher(makeAutoPtrUsingDeclMatcher(), this);
+    Finder->addMatcher(makeTransferOwnershipExprMatcher(), this);
+  }
 }
 
 void ReplaceAutoPtrCheck::registerPPCallbacks(CompilerInstance &Compiler) {
-  Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                     Compiler.getLangOpts(), IncludeStyle));
-  Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
+  // Only register the preprocessor callbacks for C++; the functionality
+  // currently does not provide any benefit to other languages, despite being
+  // benign.
+  if (getLangOpts().CPlusPlus) {
+    Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
+                                       Compiler.getLangOpts(), IncludeStyle));
+    Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
+  }
 }
 
 void ReplaceAutoPtrCheck::check(const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

@@ -238,8 +238,12 @@ StatementMatcher makeDeclWithNewMatcher() {
 } // namespace
 
 void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(makeIteratorDeclMatcher(), this);
-  Finder->addMatcher(makeDeclWithNewMatcher(), this);
+  // Only register the matchers for C++; the functionality currently does not
+  // provide any benefit to other languages, despite being benign.
+  if (getLangOpts().CPlusPlus) {
+    Finder->addMatcher(makeIteratorDeclMatcher(), this);
+    Finder->addMatcher(makeDeclWithNewMatcher(), this);
+  }
 }
 
 void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {

clang-tools-extra/test/clang-tidy/modernize-loop-convert.c

@@ -0,0 +1,12 @@
+// RUN: clang-tidy %s -checks=-*,modernize-loop-convert -- -std=c11 | count 0
+
+// Note: this test expects no diagnostics, but FileCheck cannot handle that,
+// hence the use of | count 0.
+
+int arr[6] = {1, 2, 3, 4, 5, 6};
+
+void f(void) {
+  for (int i = 0; i < 6; ++i) {
+    (void)arr[i];
+  }
+}