Replaced C++2a with C++20 in clang-tools-extra

[aaron.ballman]

LGTM!

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

void ProTypeMemberInitCheck::checkMissingMemberInitializer(
   // as initializing more than one union member is an error.
   SmallPtrSet<const FieldDecl *, 16> FieldsToFix;
   SmallPtrSet<const RecordDecl *, 4> UnionsSeen;
   forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) {
     if (!FieldsToInit.count(F))
       return;
     // Don't suggest fixes for enums because we don't know a good default.
     // Don't suggest fixes for bitfields because in-class initialization is not
-    // possible until C++2a.
+    // possible until C++20.
     if (F->getType()->isEnumeralType() ||
         (!getLangOpts().CPlusPlus20 && F->isBitField()))
       return;
     if (!F->getParent()->isUnion() || UnionsSeen.insert(F->getParent()).second)
       FieldsToFix.insert(F);
   });
   if (FieldsToFix.empty())
     return;

clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp

EXPECT_THAT(
           AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
                 Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
                                SymNameRange(Main.range("decl"))))),
           AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
                 SymNameRange(Main.range("def")))));
 }
 
 TEST_F(DocumentSymbolsTest, Concepts) {
-  CDB.ExtraClangFlags = {"-std=c++2a"};
+  CDB.ExtraClangFlags = {"-std=c++20"};
   std::string FilePath = testPath("foo.cpp");
   addFile(FilePath,
           "template <typename T> concept C = requires(T t) { t.foo(); };");
 
   EXPECT_THAT(getSymbols(FilePath), ElementsAre(WithName("C")));
 }
 
 TEST_F(DocumentSymbolsTest, ExternSymbol) {

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

Code = R"cpp(
     template <typename T>
     concept Fooable = requires (T t) { t.foo(); };
 
     template <typename T> requires [[Fooable]]<T>
     void bar(T t) {
       t.foo();
     }
   )cpp";
-  Flags.push_back("-std=c++2a");
+  Flags.push_back("-std=c++20");
   EXPECT_DECLS(
       "ConceptSpecializationExpr",
       // FIXME: Should we truncate the pretty-printed form of a concept decl
       // somewhere?
       {"template <typename T> concept Fooable = requires (T t) { t.foo(); };"});
 }
 
 TEST_F(TargetDeclTest, FunctionTemplate) {
protected:
   /// See actual tests for examples of annotation format.
   AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     TestTU TU;
     TU.Code = std::string(Code);
 
     // FIXME: Auto-completion in a template requires disabling delayed template
     // parsing.
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
-    TU.ExtraArgs.push_back("-std=c++2a");
+    TU.ExtraArgs.push_back("-std=c++20");
     TU.ExtraArgs.push_back("-xobjective-c++");
 
     auto AST = TU.build();
     auto *TestDecl = &findDecl(AST, "foo");
     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
       TestDecl = T->getTemplatedDecl();
 
     std::vector<ReferenceLoc> Refs;

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

void checkHighlightings(llvm::StringRef Code,
                             AdditionalFiles = {}) {
   Annotations Test(Code);
   TestTU TU;
   TU.Code = std::string(Test.code());
 
   // FIXME: Auto-completion in a template requires disabling delayed template
   // parsing.
   TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
-  TU.ExtraArgs.push_back("-std=c++2a");
+  TU.ExtraArgs.push_back("-std=c++20");
 
   for (auto File : AdditionalFiles)
     TU.AdditionalFiles.insert({File.first, std::string(File.second)});
   auto AST = TU.build();
 
   EXPECT_EQ(Code, annotate(Test.code(), getSemanticHighlightings(AST)));
 }
 

clang-tools-extra/docs/clang-tidy/checks/portability-simd-intrinsics.rst

.. option:: Suggest
 
    If this option is set to non-zero (default is `0`), the check will suggest
    `P0214`_ alternatives, otherwise it only points out the intrinsic function is
    non-portable.
 
 .. option:: Std
 
    The namespace used to suggest `P0214`_ alternatives. If not specified, `std::`
-   for `-std=c++2a` and `std::experimental::` for `-std=c++11`.
+   for `-std=c++20` and `std::experimental::` for `-std=c++11`.
 
 .. _P0214: https://wg21.link/p0214

clang-tools-extra/test/clang-tidy/check_clang_tidy.py

try:
           stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
       print('FileCheck failed:\n' + e.output.decode())
       raise
 
 
 def expand_std(std):
   if std == 'c++98-or-later':
-    return ['c++98', 'c++11', 'c++14', 'c++17', 'c++2a']
+    return ['c++98', 'c++11', 'c++14', 'c++17', 'c++20']
   if std == 'c++11-or-later':
-    return ['c++11', 'c++14', 'c++17', 'c++2a']
+    return ['c++11', 'c++14', 'c++17', 'c++20']
   if std == 'c++14-or-later':
-    return ['c++14', 'c++17', 'c++2a']
+    return ['c++14', 'c++17', 'c++20']
   if std == 'c++17-or-later':
-    return ['c++17', 'c++2a']
-  if std == 'c++2a-or-later':
-    return ['c++2a']
+    return ['c++17', 'c++20']
+  if std == 'c++20-or-later':
+    return ['c++20']
   return [std]
 
 
 def csv(string):
   return string.split(',')
 
 
 def main():

clang-tools-extra/test/clang-tidy/checkers/cert-mem57-cpp-cpp17.cpp

 // RUN: %check_clang_tidy %s -std=c++14 cert-mem57-cpp %t
 // RUN: clang-tidy --extra-arg='-std=c++17' --extra-arg='-faligned-allocation' -checks='-*,cert-mem57-cpp' --extra-arg=-Wno-unused-variable --warnings-as-errors='*' %s
-// RUN: clang-tidy --extra-arg='-std=c++2a' --extra-arg='-faligned-allocation' -checks='-*,cert-mem57-cpp' --extra-arg=-Wno-unused-variable --warnings-as-errors='*' %s
+// RUN: clang-tidy --extra-arg='-std=c++20' --extra-arg='-faligned-allocation' -checks='-*,cert-mem57-cpp' --extra-arg=-Wno-unused-variable --warnings-as-errors='*' %s
 
 struct alignas(128) Vector {
   char Elems[128];
 };
 
 void f() {
   auto *V1 = new Vector;        // CHECK-MESSAGES: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [cert-mem57-cpp]
   auto *V1_Arr = new Vector[2]; // CHECK-MESSAGES: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [cert-mem57-cpp]
 }

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

-// RUN: %check_clang_tidy -std=c++2a %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++20 %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
 
 struct PositiveBitfieldMember {
   PositiveBitfieldMember() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these fields: F
   unsigned F : 5;
   // CHECK-FIXES: unsigned F : 5{};
 };
 

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

 // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
-// FIXME: Fix the checker to work in C++2a mode.
+// FIXME: Fix the checker to work in C++20 mode.
 
 struct PositiveFieldBeforeConstructor {
   int F;
   // CHECK-FIXES: int F{};
   PositiveFieldBeforeConstructor() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these fields: F
   // CHECK-FIXES: PositiveFieldBeforeConstructor() {}
 };

clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-inaccessible-ctors.cpp

 // RUN: %check_clang_tidy -std=c++14,c++17 -check-suffix=CXX-14-17 %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr -D CXX_14_17=1
-// RUN: %check_clang_tidy -std=c++2a -check-suffix=CXX-2A %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr -D CXX_2A=1
+// RUN: %check_clang_tidy -std=c++20 -check-suffix=CXX-20 %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr -D CXX_20=1
 
 #include "unique_ptr.h"
 // CHECK-FIXES: #include <memory>
 
 struct NoCopyMoveCtor {
-#ifdef CXX_2A
-  // C++2a requires to see the default constructor, otherwise it is illgal.
+#ifdef CXX_20
+  // C++20 requires to see the default constructor, otherwise it is illgal.
   NoCopyMoveCtor() = default;
 #endif
 #ifdef CXX_14_17
   int a, b;
 #endif
   NoCopyMoveCtor(const NoCopyMoveCtor &) = delete; // implies move ctor is deleted
 };
 
 struct NoCopyMoveCtorVisible {
-#ifdef CXX_2A
+#ifdef CXX_20
   NoCopyMoveCtorVisible() = default;
 #endif
 private:
   NoCopyMoveCtorVisible(const NoCopyMoveCtorVisible&) = default;
   NoCopyMoveCtorVisible(NoCopyMoveCtorVisible&&) = default;
 };
 
 struct OnlyMoveCtor {
   OnlyMoveCtor() = default;
   OnlyMoveCtor(OnlyMoveCtor&&) = default;
   OnlyMoveCtor(const OnlyMoveCtor &) = delete;
 };
 
 struct OnlyCopyCtor {
-#ifdef CXX_2A
+#ifdef CXX_20
   OnlyCopyCtor() = default;
 #endif
   OnlyCopyCtor(const OnlyCopyCtor&) = default;
   OnlyCopyCtor(OnlyCopyCtor&&) = delete;
 };
 
 struct OnlyCopyCtorVisible {
-#ifdef CXX_2A
+#ifdef CXX_20
   OnlyCopyCtorVisible() = default;
 #endif
   OnlyCopyCtorVisible(const OnlyCopyCtorVisible &) = default;
 
 private:
   OnlyCopyCtorVisible(OnlyCopyCtorVisible &&) = default;
 };
 
 struct ImplicitDeletedCopyCtor {
   const OnlyMoveCtor ctor;
 };
 
 void f() {
   auto my_ptr = std::unique_ptr<int>(new int(1));
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:17: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto my_ptr = std::make_unique<int>(1);
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:17: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto my_ptr = std::make_unique<int>(1);
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:17: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto my_ptr = std::make_unique<int>(1);
 
-  // "new NoCopyMoveCtor{}" is processed differently in C++14/17 and C++2a:
+  // "new NoCopyMoveCtor{}" is processed differently in C++14/17 and C++20:
   //   * In C++14/17, it is recognized as aggregate initialization,
   //     no fixes will be generated although the generated fix is compilable.
-  //   * In C++2a, it is is recognized as default constructor initialization (
-  //     similar to "new NoCopyMoveCtor()"), the check will emit the fix and the
-  //     fix is correct.
+  //   * In C++20, it is is recognized as default constructor initialization
+  //     (similar to "new NoCopyMoveCtor()"), the check will emit the fix and
+  //     the fix is correct.
   auto PNoCopyMoveCtor = std::unique_ptr<NoCopyMoveCtor>(new NoCopyMoveCtor{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:26: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto PNoCopyMoveCtor = std::unique_ptr<NoCopyMoveCtor>(new NoCopyMoveCtor{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:26: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto PNoCopyMoveCtor = std::make_unique<NoCopyMoveCtor>();
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:26: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto PNoCopyMoveCtor = std::make_unique<NoCopyMoveCtor>();
 
   auto PNoCopyMoveCtorVisible = std::unique_ptr<NoCopyMoveCtorVisible>(new NoCopyMoveCtorVisible{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:33: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto PNoCopyMoveCtorVisible = std::unique_ptr<NoCopyMoveCtorVisible>(new NoCopyMoveCtorVisible{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:33: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto PNoCopyMoveCtorVisible = std::make_unique<NoCopyMoveCtorVisible>();
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:33: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto PNoCopyMoveCtorVisible = std::make_unique<NoCopyMoveCtorVisible>();
 
   auto POnlyMoveCtor = std::unique_ptr<OnlyMoveCtor>(new OnlyMoveCtor{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:24: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto POnlyMoveCtor = std::unique_ptr<OnlyMoveCtor>(new OnlyMoveCtor{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:24: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto POnlyMoveCtor = std::make_unique<OnlyMoveCtor>();
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:24: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto POnlyMoveCtor = std::make_unique<OnlyMoveCtor>();
 
   auto POnlyCopyCtor = std::unique_ptr<OnlyCopyCtor>(new OnlyCopyCtor{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:24: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto POnlyCopyCtor = std::unique_ptr<OnlyCopyCtor>(new OnlyCopyCtor{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:24: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto POnlyCopyCtor = std::make_unique<OnlyCopyCtor>();
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:24: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto POnlyCopyCtor = std::make_unique<OnlyCopyCtor>();
 
   auto POnlyCopyCtorVisible = std::unique_ptr<OnlyCopyCtorVisible>(new OnlyCopyCtorVisible{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:31: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto POnlyCopyCtorVisible = std::unique_ptr<OnlyCopyCtorVisible>(new OnlyCopyCtorVisible{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:31: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto POnlyCopyCtorVisible = std::make_unique<OnlyCopyCtorVisible>();
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:31: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto POnlyCopyCtorVisible = std::make_unique<OnlyCopyCtorVisible>();
 
-  // This is aggregate initialization in C++2a, no fix will be generated.
+  // This is aggregate initialization in C++20, no fix will be generated.
   auto PImplicitDeletedCopyCtor = std::unique_ptr<ImplicitDeletedCopyCtor>(new ImplicitDeletedCopyCtor{});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:35: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto PImplicitDeletedCopyCtor = std::unique_ptr<ImplicitDeletedCopyCtor>(new ImplicitDeletedCopyCtor{});
-  // CHECK-MESSAGES-CXX-2A: :[[@LINE-3]]:35: warning: use std::make_unique instead
-  // CHECK-FIXES-CXX-2A: auto PImplicitDeletedCopyCtor = std::unique_ptr<ImplicitDeletedCopyCtor>(new ImplicitDeletedCopyCtor{});
+  // CHECK-MESSAGES-CXX-20: :[[@LINE-3]]:35: warning: use std::make_unique instead
+  // CHECK-FIXES-CXX-20: auto PImplicitDeletedCopyCtor = std::unique_ptr<ImplicitDeletedCopyCtor>(new ImplicitDeletedCopyCtor{});
 
 
 #ifdef CXX_14_17
   // FIXME: it is impossible to use make_unique for this case, the check should
   // stop emitting the message.
   auto PNoCopyMoveCtor2 = std::unique_ptr<NoCopyMoveCtor>(new NoCopyMoveCtor{1, 2});
   // CHECK-MESSAGES-CXX-14-17: :[[@LINE-1]]:27: warning: use std::make_unique instead
   // CHECK-FIXES-CXX-14-17: auto PNoCopyMoveCtor2 = std::unique_ptr<NoCopyMoveCtor>(new NoCopyMoveCtor{1, 2});
 #endif
 }

clang-tools-extra/test/clang-tidy/checkers/modernize-raw-string-literal.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}"
-// FIXME: Fix the checker to work in C++2a mode.
+// FIXME: Fix the checker to work in C++20 mode.
 
 char const *const BackSlash("goink\\frob");
 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal]
 // CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}}
 
 char const *const PlainLiteral("plain literal");
 
 // Non-printable ASCII characters.

clang-tools-extra/test/clang-tidy/checkers/modernize-use-default-member-init-bitfield.cpp

-// RUN: %check_clang_tidy -std=c++2a-or-later %s modernize-use-default-member-init %t
+// RUN: %check_clang_tidy -std=c++20-or-later %s modernize-use-default-member-init %t
 
 struct PositiveBitField
 {
   PositiveBitField() : i(6) {}
   // CHECK-FIXES: PositiveBitField()  {}
   int i : 5;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use default member initializer for 'i' [modernize-use-default-member-init]
   // CHECK-FIXES: int i : 5{6};
 };

clang-tools-extra/test/clang-tidy/checkers/modernize-use-default-member-init.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s modernize-use-default-member-init %t -- -- -fexceptions
-// FIXME: Fix the checker to work in C++2a mode.
+// FIXME: Fix the checker to work in C++20 mode.
 
 struct S {
 };
 
 struct PositiveValueChar {
   PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {}
   // CHECK-FIXES: PositiveValueChar()  {}
   const char c0;

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

 // RUN: %check_clang_tidy -std=c++14,c++17 %s modernize-use-trailing-return-type %t -- -- -fdeclspec -fexceptions
-// FIXME: Fix the checker to work in C++2a mode, it is performing a
+// FIXME: Fix the checker to work in C++20 mode, it is performing a
 // use-of-uninitialized-value.
 
 namespace std {
     template <typename T>
     class vector;
 
     template <typename T, int N>
     class array;

clang-tools-extra/test/clang-tidy/checkers/performance-no-automatic-move.cpp

-// RUN: %check_clang_tidy -std=c++11,c++14,c++17,c++2a %s performance-no-automatic-move %t
+// RUN: %check_clang_tidy -std=c++11-or-later %s performance-no-automatic-move %t
 
 struct Obj {
   Obj();
   Obj(const Obj &);
   Obj(Obj &&);
   virtual ~Obj();
 };
 

clang-tools-extra/test/clang-tidy/checkers/portability-simd-intrinsics-ppc.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
 // RUN:  -config='{CheckOptions: [ \
 // RUN:    {key: portability-simd-intrinsics.Suggest, value: 1} \
 // RUN:  ]}' -- -target ppc64le -maltivec
-// FIXME: Fix the checker to work in C++2a mode.
+// FIXME: Fix the checker to work in C++20 mode.
 
 vector int vec_add(vector int, vector int);
 
 void PPC() {
   vector int i0, i1;
 
   vec_add(i0, i1);
 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [portability-simd-intrinsics]
 }

clang-tools-extra/test/clang-tidy/checkers/portability-simd-intrinsics-x86.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
 // RUN:  -config='{CheckOptions: [ \
 // RUN:    {key: portability-simd-intrinsics.Suggest, value: 1} \
 // RUN:  ]}' -- -target x86_64
-// FIXME: Fix the checker to work in C++2a mode.
+// FIXME: Fix the checker to work in C++20 mode.
 
 typedef long long __m128i __attribute__((vector_size(16)));
 typedef double __m256 __attribute__((vector_size(32)));
 
 __m128i _mm_add_epi32(__m128i, __m128i);
 __m256 _mm256_load_pd(double const *);
 void _mm256_store_pd(double *, __m256);
 

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

-// RUN: %check_clang_tidy -std=c++2a-or-later %s readability-use-anyofallof %t
+// RUN: %check_clang_tidy -std=c++20-or-later %s readability-use-anyofallof %t
 
 bool good_any_of() {
   int v[] = {1, 2, 3};
   // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: replace loop by 'std::ranges::any_of()'
   for (int i : v)
     if (i)
       return true;
   return false;