[C++20][ClangTidy] Update the ClangTidy tests to also test in C++20 mode

[gribozavr2]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/pro-type-member-init-cxx98.cpp

2 ↗

(On Diff #499146)

Please revert this unnecessary change.

clang-tools-extra/unittests/clang-tidy/ClangTidyTest.h

113 ↗

(On Diff #499146)

Could you break this out into a separate commit with a description like "change ClangTidy unit tests to run in C++20 mode instead of C++11". This is a change, not an extension ("also run in C++20").

[usaxena95]

Addressed comments.

clang-tools-extra/test/clang-tidy/checkers/bugprone/dangling-handle.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-dangling-handle %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: bugprone-dangling-handle.HandleClasses, \
 // RUN:               value: 'std::basic_string_view; ::llvm::StringRef;'}]}"
-// FIXME: Fix the checker to work in C++17 mode.
+// FIXME: Fix the checker to work in C++17 or later mode.
 
 namespace std {
 
 template <typename T>
 class vector {
  public:
   using const_iterator = const T*;
   using iterator = T*;

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicits.cpp

-// RUN: %check_clang_tidy -std=c++17 %s bugprone-easily-swappable-parameters %t \
+// RUN: %check_clang_tidy -std=c++17-or-later %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \

clang-tools-extra/test/clang-tidy/checkers/bugprone/exception-escape.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-exception-escape %t -- \
 // RUN:     -config="{CheckOptions: [ \
 // RUN:         {key: bugprone-exception-escape.IgnoredExceptions, value: 'ignored1,ignored2'}, \
 // RUN:         {key: bugprone-exception-escape.FunctionsThatShouldNotThrow, value: 'enabled1,enabled2,enabled3'} \
 // RUN:     ]}" \
 // RUN:     -- -fexceptions
+// FIXME: Fix the checker to work in C++17 or later mode.
 
 struct throwing_destructor {
   ~throwing_destructor() {
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function '~throwing_destructor' which should not throw exceptions
     throw 1;
   }
 };
 

clang-tools-extra/test/clang-tidy/checkers/bugprone/signal-handler.cpp

 // RUN: %check_clang_tidy -std=c++14 %s bugprone-signal-handler %t -- -- -isystem %clang_tidy_headers -isystem %S/Inputs/signal-handler -target x86_64-unknown-unknown
-
+// FIXME: Fix the checker to work in C++17 or later mode.
 #include "stdcpp.h"
 #include "stdio.h"
 
 // Functions called "signal" that are different from the system version.
 typedef void (*callback_t)(int);
 void signal(int, callback_t, int);
 namespace ns {
 void signal(int, callback_t);

clang-tools-extra/test/clang-tidy/checkers/bugprone/unhandled-exception-at-new.cpp

 // RUN: %check_clang_tidy -std=c++14 %s bugprone-unhandled-exception-at-new %t -- -- -fexceptions
-
+// FIXME: Fix the checker to work in C++17 or later mode.
 namespace std {
 typedef __typeof__(sizeof(0)) size_t;
 enum class align_val_t : std::size_t {};
 class exception {};
 class bad_alloc : public exception {};
 class bad_array_new_length : public bad_alloc {};
 struct nothrow_t {};
 extern const nothrow_t nothrow;

clang-tools-extra/test/clang-tidy/checkers/cert/throw-exception-type.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14 %s cert-err60-cpp %t -- -- -fcxx-exceptions
 // FIXME: Split off parts of this test that rely on dynamic exception
 // specifications, and run this test in all language modes.
-
+// FIXME: Fix the checker to work in C++17 or later mode.
 struct S {};
 struct T : S {};
 struct U {
   U() = default;
   U(const U&) = default;
 };
 
 struct V {

clang-tools-extra/test/clang-tidy/checkers/misc/static-assert.cpp

 // RUN: %check_clang_tidy -std=c++11 -check-suffixes=,CXX11 %s misc-static-assert %t
-// RUN: %check_clang_tidy -std=c++17 -check-suffixes=,CXX17 %s misc-static-assert %t
+// RUN: %check_clang_tidy -std=c++17-or-later -check-suffixes=,CXX17 %s misc-static-assert %t
 
 void abort() {}
 #ifdef NDEBUG
 #define assert(x) 1
 #else
 #define assert(x)                                                              \
   if (!(x))                                                                    \
   abort()

clang-tools-extra/test/clang-tidy/checkers/performance/unnecessary-copy-initialization.cpp

-// RUN: %check_clang_tidy -std=c++17 %s performance-unnecessary-copy-initialization %t
+// RUN: %check_clang_tidy -std=c++17-or-later %s performance-unnecessary-copy-initialization %t
 
 template <typename T>
 struct Iterator {
   void operator++();
   T &operator*() const;
   bool operator!=(const Iterator &) const;
   typedef const T &const_reference;
 };

clang-tools-extra/test/clang-tidy/checkers/readability/const-return-type-macros.cpp

-// RUN: %check_clang_tidy -std=c++14 %s readability-const-return-type %t -- \
+// RUN: %check_clang_tidy -std=c++14-or-later %s readability-const-return-type %t -- \
 // RUN:   -config="{CheckOptions: [{key: readability-const-return-type.IgnoreMacros, value: false}]}"
 
 //  p# = positive test
 //  n# = negative test
 
 // Regression tests involving macros
 #define CONCAT(a, b) a##b
 CONCAT(cons, t) int p22(){}

clang-tools-extra/test/clang-tidy/checkers/readability/const-return-type.cpp

-// RUN: %check_clang_tidy -std=c++14 %s readability-const-return-type %t
+// RUN: %check_clang_tidy -std=c++14-or-later %s readability-const-return-type %t
 
 //  p# = positive test
 //  n# = negative test
 
 namespace std {
 template< class T >
 struct add_cv { typedef const volatile T type; };
 

clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-cxx17.cpp

-// RUN: %check_clang_tidy -std=c++17 %s readability-isolate-declaration %t
+// RUN: %check_clang_tidy -std=c++17-or-later %s readability-isolate-declaration %t
 
 template <typename T1, typename T2>
 struct pair {
   T1 first;
   T2 second;
   pair(T1 v1, T2 v2) : first(v1), second(v2) {}
 
   template <int N>

clang-tools-extra/test/clang-tidy/checkers/readability/use-anyofallof.cpp

 // RUN: %check_clang_tidy -std=c++14,c++17 %s readability-use-anyofallof %t -- -- -fexceptions
+// FIXME: Fix the checker to work in C++20 mode.
 
 bool good_any_of() {
   int v[] = {1, 2, 3};
   // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::any_of()' [readability-use-anyofallof]
   for (int i : v)
     if (i)
       return true;
   return false;