[clang-tidy] Updated language supported restrictions on some checks

[alexfh]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

IIRC, some of the modernize- checks were meant to be useful to make the pre-C++11 code compile in C++11. This check is an example of this (maybe the only one?). Limiting the check to C++11 and deleting this test is a bit too radical.

[njames93]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

I'm lost, this check is all about replacing assignment of pointer to 0 with nullptr a keyword which doesn't exist pre c++11, so this test case will just result in invalid code. Or am I missing the point?

[gribozavr2]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

The idea, if I understand correctly, is that you start with C++98 code, apply modernize-* checks, and get C++11 code.

[alexfh]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

Yep, at least for this particular check there are cases, which won't compile in C++11, but will compile after its fixes are applied. Not sure if this was ever used like this though.

[njames93]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

My understanding of the modernize module was its designed to convert the old c++98/03 code to use newer (safer) c++ constructs. Its purpose isn't to fix compiler errors in c++11 mode that compile OK in c++98 mode

[alexfh]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

1

This and a number of other modernize- checks were migrated from the clang-modernize (previously cpp11-migrate) tool. It's hard to tell now, whether running on code in C++98 mode and fixing errors that would appear in C++11 was a supported use case at the time (though all commits are in git and one could look up, if someone wants to). But that's irrelevant. We need to decide now, whether we want to support this use case or not.
I believe, fixing C++11 compatibility errors in valid C++98 code is a potentially useful feature. Given that it doesn't require additional maintenance costs, I think we should leave it as is. The only downside is complaints from users who blindly run _all_ the checks regardless of whether they need them or not. We could try to relieve this pain, but a better treatment here would be to use the tool correctly, i.e. carefully select the checks to enable. That seems to partly be a UX problem of the frontend they use (CLion in the recent bug report - https://www.jetbrains.com/help/clion/clang-tidy-checks-support.html). Some UIs try to be more user-friendly w.r.t. configuration of the checks (e.g. I found this one today: https://www.cppdepend.com/Modernize).

clang-tools-extra/clang-tidy/cert/DefaultOperatorNewAlignmentCheck.h

 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cert-mem57-cpp.html
 class DefaultOperatorNewAlignmentCheck : public ClangTidyCheck {
 public:
   DefaultOperatorNewAlignmentCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return !LangOpts.CPlusPlus17;
+    return LangOpts.CPlusPlus && !LangOpts.CPlusPlus17;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H

clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.cpp

 namespace google {
 
 void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       cxxConstructorDecl(unless(anyOf(isImplicit(), // Compiler-generated.
                                       isDeleted(), isInstantiated())))
           .bind("ctor"),
       this);
+  if (!getLangOpts().CPlusPlus11)
+    return;
   Finder->addMatcher(
       cxxConversionDecl(unless(anyOf(isExplicit(), // Already marked explicit.
                                      isImplicit(), // Compiler-generated.
                                      isDeleted(), isInstantiated())))
 
           .bind("conversion"),
       this);
 }

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

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class LoopConvertCheck : public ClangTidyCheck {
 public:
   LoopConvertCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   struct RangeDescriptor {
     RangeDescriptor();

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

 /// \code
 ///   std::unique_ptr<in> i, j;
 ///   i = std::move(j);
 /// \endcode
 class ReplaceAutoPtrCheck : public ClangTidyCheck {
 public:
   ReplaceAutoPtrCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:

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

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class UseAutoCheck : public ClangTidyCheck {
 public:
   UseAutoCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void replaceIterators(const DeclStmt *D, ASTContext *Context);
   void replaceExpr(const DeclStmt *D, ASTContext *Context,

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.h

 /// \endcode
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html
 class UseEqualsDefaultCheck : public ClangTidyCheck {
 public:
   UseEqualsDefaultCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool IgnoreMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.h

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html
 class UseEqualsDeleteCheck : public ClangTidyCheck {
 public:
   UseEqualsDeleteCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool IgnoreMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DELETE_H

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.h

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class UseNullptrCheck : public ClangTidyCheck {
 public:
   UseNullptrCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    // FIXME this should be CPlusCplus11 but that causes test cases to
-    // erroneously fail.
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const std::string NullMacrosStr;
   SmallVector<StringRef, 1> NullMacros;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.h

 //      types as their objects are not moved but copied. Enabled by default.
 class MoveConstArgCheck : public ClangTidyCheck {
 public:
   MoveConstArgCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),
         CheckTriviallyCopyableMove(
             Options.get("CheckTriviallyCopyableMove", true)) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.CPlusPlus;
+    return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool CheckTriviallyCopyableMove;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

-// RUN: %check_clang_tidy -std=c++98 %s modernize-use-nullptr %t -- -- -Wno-non-literal-null-conversion
-//
-// Some parts of the test (e.g. assignment of `const int` to `int *`) fail in
-// C++11, so we need to run the test in C++98 mode.
-//
-// FIXME: Make the test work in all language modes.
-
-const unsigned int g_null = 0;
-#define NULL 0
-
-void test_assignment() {
-  int *p1 = 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr [modernize-use-nullptr]
-  // CHECK-FIXES: int *p1 = nullptr;
-  p1 = 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr
-  // CHECK-FIXES: p1 = nullptr;
-
-  int *p2 = NULL;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
-  // CHECK-FIXES: int *p2 = nullptr;
-
-  p2 = p1;
-  // CHECK-FIXES: p2 = p1;
-
-  const int null = 0;
-  int *p3 = null;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
-  // CHECK-FIXES: int *p3 = nullptr;
-
-  p3 = NULL;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr
-  // CHECK-FIXES: p3 = nullptr;
-
-  int *p4 = p3;
-  // CHECK-FIXES: int *p4 = p3;
-
-  p4 = null;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr
-  // CHECK-FIXES: p4 = nullptr;
-
-  int i1 = 0;
-
-  int i2 = NULL;
-
-  int i3 = null;
-
-  int *p5, *p6, *p7;
-  p5 = p6 = p7 = NULL;
-  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr
-  // CHECK-FIXES: p5 = p6 = p7 = nullptr;
-}
-
-struct Foo {
-  Foo(int *p = NULL) : m_p1(p) {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use nullptr
-  // CHECK-FIXES: Foo(int *p = nullptr) : m_p1(p) {}
-
-  void bar(int *p = 0) {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use nullptr
-  // CHECK-FIXES: void bar(int *p = nullptr) {}
-
-  void baz(int i = 0) {}
-
-  int *m_p1;
-  static int *m_p2;
-};
-
-int *Foo::m_p2 = NULL;
-// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr
-// CHECK-FIXES: int *Foo::m_p2 = nullptr;
-
-template <typename T>
-struct Bar {
-  Bar(T *p) : m_p(p) {
-    m_p = static_cast<T*>(NULL);
-    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr
-    // CHECK-FIXES: m_p = static_cast<T*>(nullptr);
-
-    m_p = static_cast<T*>(reinterpret_cast<int*>((void*)NULL));
-    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr
-    // CHECK-FIXES: m_p = static_cast<T*>(nullptr);
-
-    m_p = static_cast<T*>(p ? p : static_cast<void*>(g_null));
-    // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: use nullptr
-    // CHECK-FIXES: m_p = static_cast<T*>(p ? p : static_cast<void*>(nullptr));
-
-    T *p2 = static_cast<T*>(reinterpret_cast<int*>((void*)NULL));
-    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr
-    // CHECK-FIXES: T *p2 = static_cast<T*>(nullptr);
-
-    m_p = NULL;
-    // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use nullptr
-    // CHECK-FIXES: m_p = nullptr;
-
-    int i = static_cast<int>(0.f);
-    T *i2 = static_cast<int>(0.f);
-    // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
-    // CHECK-FIXES: T *i2 = nullptr;
-  }
-
-  T *m_p;
-};
-
-struct Baz {
-  Baz() : i(0) {}
-  int i;
-};
-
-void test_cxx_cases() {
-  Foo f(g_null);
-  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
-  // CHECK-FIXES: Foo f(nullptr);
-
-  f.bar(NULL);
-  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
-  // CHECK-FIXES: f.bar(nullptr);
-
-  f.baz(g_null);
-
-  f.m_p1 = 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr
-  // CHECK-FIXES: f.m_p1 = nullptr;
-
-  Bar<int> b(g_null);
-  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use nullptr
-  // CHECK-FIXES: Bar<int> b(nullptr);
-
-  Baz b2;
-  int Baz::*memptr(0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use nullptr
-  // CHECK-FIXES: int Baz::*memptr(nullptr);
-
-  memptr = 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr
-  // CHECK-FIXES: memptr = nullptr;
-}
-
-void test_function_default_param1(void *p = 0);
-// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
-// CHECK-FIXES: void test_function_default_param1(void *p = nullptr);
-
-void test_function_default_param2(void *p = NULL);
-// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
-// CHECK-FIXES: void test_function_default_param2(void *p = nullptr);
-
-void test_function_default_param3(void *p = g_null);
-// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
-// CHECK-FIXES: void test_function_default_param3(void *p = nullptr);
-
-void test_function(int *p) {}
-
-void test_function_no_ptr_param(int i) {}
-
-void test_function_call() {
-  test_function(0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
-  // CHECK-FIXES: test_function(nullptr);
-
-  test_function(NULL);
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
-  // CHECK-FIXES: test_function(nullptr);
-
-  test_function(g_null);
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
-  // CHECK-FIXES: test_function(nullptr);
-
-  test_function_no_ptr_param(0);
-}
-
-char *test_function_return1() {
-  return 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
-  // CHECK-FIXES: return nullptr;
-}
-
-void *test_function_return2() {
-  return NULL;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
-  // CHECK-FIXES: return nullptr;
-}
-
-long *test_function_return3() {
-  return g_null;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
-  // CHECK-FIXES: return nullptr;
-}
-
-int test_function_return4() {
-  return 0;
-}
-
-int test_function_return5() {
-  return NULL;
-}
-
-int test_function_return6() {
-  return g_null;
-}
-
-int *test_function_return_cast1() {
-  return(int)0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
-  // CHECK-FIXES: return nullptr;
-}
-
-int *test_function_return_cast2() {
-#define RET return
-  RET(int)0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use nullptr
-  // CHECK-FIXES: RET nullptr;
-#undef RET
-}
-
-// Test parentheses expressions resulting in a nullptr.
-int *test_parentheses_expression1() {
-  return(0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
-  // CHECK-FIXES: return(nullptr);
-}
-
-int *test_parentheses_expression2() {
-  return(int(0.f));
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
-  // CHECK-FIXES: return(nullptr);
-}
-
-int *test_nested_parentheses_expression() {
-  return((((0))));
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
-  // CHECK-FIXES: return((((nullptr))));
-}
-
-void *test_parentheses_explicit_cast() {
-  return(static_cast<void*>(0));
-  // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr
-  // CHECK-FIXES: return(static_cast<void*>(nullptr));
-}
-
-void *test_parentheses_explicit_cast_sequence1() {
-  return(static_cast<void*>(static_cast<int*>((void*)NULL)));
-  // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr
-  // CHECK-FIXES: return(static_cast<void*>(nullptr));
-}
-
-void *test_parentheses_explicit_cast_sequence2() {
-  return(static_cast<void*>(reinterpret_cast<int*>((float*)int(0.f))));
-  // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr
-  // CHECK-FIXES: return(static_cast<void*>(nullptr));
-}
-
-// Test explicit cast expressions resulting in nullptr.
-struct Bam {
-  Bam(int *a) {}
-  Bam(float *a) {}
-  Bam operator=(int *a) { return Bam(a); }
-  Bam operator=(float *a) { return Bam(a); }
-};
-
-void ambiguous_function(int *a) {}
-void ambiguous_function(float *a) {}
-void const_ambiguous_function(const int *p) {}
-void const_ambiguous_function(const float *p) {}
-
-void test_explicit_cast_ambiguous1() {
-  ambiguous_function((int*)0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use nullptr
-  // CHECK-FIXES: ambiguous_function((int*)nullptr);
-}
-
-void test_explicit_cast_ambiguous2() {
-  ambiguous_function((int*)(0));
-  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use nullptr
-  // CHECK-FIXES: ambiguous_function((int*)nullptr);
-}
-
-void test_explicit_cast_ambiguous3() {
-  ambiguous_function(static_cast<int*>(reinterpret_cast<int*>((float*)0)));
-  // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use nullptr
-  // CHECK-FIXES: ambiguous_function(static_cast<int*>(nullptr));
-}
-
-Bam test_explicit_cast_ambiguous4() {
-  return(((int*)(0)));
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
-  // CHECK-FIXES: return(((int*)nullptr));
-}
-
-void test_explicit_cast_ambiguous5() {
-  // Test for ambiguous overloaded constructors.
-  Bam k((int*)(0));
-  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use nullptr
-  // CHECK-FIXES: Bam k((int*)nullptr);
-
-  // Test for ambiguous overloaded operators.
-  k = (int*)0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
-  // CHECK-FIXES: k = (int*)nullptr;
-}
-
-void test_const_pointers_abiguous() {
-  const_ambiguous_function((int*)0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use nullptr
-  // CHECK-FIXES: const_ambiguous_function((int*)nullptr);
-}
-
-// Test where the implicit cast to null is surrounded by another implicit cast
-// with possible explicit casts in-between.
-void test_const_pointers() {
-  const int *const_p1 = 0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
-  // CHECK-FIXES: const int *const_p1 = nullptr;
-  const int *const_p2 = NULL;
-  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
-  // CHECK-FIXES: const int *const_p2 = nullptr;
-  const int *const_p3 = (int)0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
-  // CHECK-FIXES: const int *const_p3 = nullptr;
-  const int *const_p4 = (int)0.0f;
-  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
-  // CHECK-FIXES: const int *const_p4 = nullptr;
-  const int *const_p5 = (int*)0;
-  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use nullptr
-  // CHECK-FIXES: const int *const_p5 = (int*)nullptr;
-  int *t;
-  const int *const_p6 = static_cast<int*>(t ? t : static_cast<int*>(0));
-  // CHECK-MESSAGES: :[[@LINE-1]]:69: warning: use nullptr
-  // CHECK-FIXES: const int *const_p6 = static_cast<int*>(t ? t : static_cast<int*>(nullptr));
-}
-
-void test_nested_implicit_cast_expr() {
-  int func0(void*, void*);
-  int func1(int, void*, void*);
-
-  (double)func1(0, 0, 0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use nullptr
-  // CHECK-MESSAGES: :[[@LINE-2]]:23: warning: use nullptr
-  // CHECK-FIXES: (double)func1(0, nullptr, nullptr);
-  (double)func1(func0(0, 0), 0, 0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use nullptr
-  // CHECK-MESSAGES: :[[@LINE-2]]:26: warning: use nullptr
-  // CHECK-MESSAGES: :[[@LINE-3]]:30: warning: use nullptr
-  // CHECK-MESSAGES: :[[@LINE-4]]:33: warning: use nullptr
-  // CHECK-FIXES: (double)func1(func0(nullptr, nullptr), nullptr, nullptr);
-}
-
-// FIXME: currently, the check doesn't work as it should with templates.
-template<typename T>
-class A {
- public:
-  A(T *p = NULL) {}
-
-  void f() {
-    Ptr = NULL;
-  }
-  T *Ptr;
-};
-
-template<typename T>
-T *f2(T *a = NULL) {
-  return a ? a : NULL;
-}