[clang] tests: cleanup, update and add some new ones

[mizvekov]

Summary

This reworks a small set of tests, as preparatory work for implementing
P2266.

• Run for more standard versions, including c++2b.
• Normalize file names and run commands.
• Adds some extra tests.

New Coroutine tests taken from Aaron Puchert's D68845.

Signed-off-by: Matheus Izvekov <[e-mail]>

[• Quuxplusone]

IMHO you should just go ahead and land the trivial trailing-whitespace changes.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

3

(1) You skipped 17.
(2) Isn't there some way to mark a Clang test as "run this in all modes '14 and later"? We shouldn't have to touch every single test every 3 years; there must be a way to do this; I just don't know what it is.

clang/test/CXX/drs/dr3xx.cpp

6

cxx98_2b is "unconditional", right?

444

This gives an error and a C++20 warning? 😛
Oh yeah. Huh. https://godbolt.org/z/eMY9zMs54 That's definitely a Clang bug. Feel like filing it?

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

3

And 11, 14, 17?

clang/test/SemaCXX/constant-expression-cxx11.cpp

3

And 14, 17?

1770

What are those trailing (occasionally doubled) backslashes doing on lines 1768–1770?
Get rid of them.
You might then need to say expected-warning@-1 and so on... which is fine.

clang/test/SemaCXX/constant-expression-cxx14.cpp

3

17?

clang/test/SemaCXX/conversion-function.cpp

5

17?

clang/test/SemaCXX/coroutine-rvo.cpp

1

Surely this should be tested in 20 (and 2b), since coroutines are a C++20 feature.

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

8

17?

clang/test/SemaCXX/return-stack-addr.cpp

3

14, 17?

[mizvekov]

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

3

1. I skipped on purpose, felt like may have been adding more than is necessary, but I can add it no problem.
2. It sucks I know, but not as far as I know. Something has to be implemented in lit for that to happen.

clang/test/CXX/drs/dr3xx.cpp

6

err, yes, I was not thinking very clearly :P

444

heh, no problem.

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

3

Again, just avoiding the extra workload there, but I can add it.

clang/test/SemaCXX/constant-expression-cxx11.cpp

1770

Err the doubled one was a typo, but I was just keeping the local style.

clang/test/SemaCXX/coroutine-rvo.cpp

1

Yeah but remember, the coroutine change was unconditional, and I don't think this test is picking up any differences for the other modes.

[mizvekov]

clang/test/CXX/drs/dr3xx.cpp

444

https://bugs.llvm.org/show_bug.cgi?id=49703

[mizvekov]

Changes per Arthur.

[mizvekov]

Normalize test tag names on clang/test/SemaCXX/P1155.cpp

[mizvekov]

Includes some new NRVO tests which will be used in D99696.

[• Quuxplusone]

LGTM (just a bunch of style comments from me), but I think you'll have to get someone else's attention if you're expecting to get signoff from someone to land this.

I also think it would make sense for you to land the absolutely trivial trailing-whitespace diffs right now without review, and then rebase this PR on top, so that those trivial whitespace diffs don't show up as distractions in this review. (In case it's useful to anyone reading: I use detab -R to strip trailing spaces and convert hard tabs.)

clang/test/SemaCXX/constant-expression-cxx11.cpp

1907–1908

I guess you're keeping the existing style here, but the existing style is not great.

Incidentally, I don't understand why Clang's error message is so dramatically different between C++11 and C++14 modes — in C++14 through 20 we get "static_assert failed" but in C++11 it wants specifically to talk about that virtual function call.
https://godbolt.org/z/1e8nqTbsb

clang/test/SemaCXX/constant-expression-cxx14.cpp

230

Many of the existing snippets are IMHO too brief, but this new snippet was IMHO too verbose.

292–295

Here's an example of "existing too brief" plus "new too verbose." The most important snippet of the diagnostic actually doesn't change between 14 and 20!

clang/test/SemaCXX/conversion-function.cpp

144

Oh this is a fun one. I almost want to ask for a code comment here, but I suppose anyone who breaks this test should be prepared to do the archeology anyway. :)

Prior to C++20 this didn't consider using AutoPtr(AutoPtrRef) to construct the return value, and so the first overload resolution (as rvalue) failed to find any candidates, and the second overload resolution (as lvalue) found the private ctor. Then in C++20 and later, we do consider AutoPtr(AutoPtrRef) during the first overload resolution, and it works fine, so the second overload resolution never happens.

160

When is this condition true?
(Honestly I'm surprised that the expected-warning parser understands #if in the first place.)

clang/test/SemaCXX/coroutine-rvo.cpp

41–45

This change makes is_trivial_v<MoveOnly> true, where before it was false.
I don't know whether this matters to the coroutine machinery. Ideally, @aaronpuchert would weigh in; I don't know, and am just raising the issue because it struck my attention.

(If it does matter, then maybe we even want to add test coverage for both the move-only-trivial case and the move-only-nontrivial case.)

144

Nit: return_template_task or generic_task would look less confusingly like template return_task... at first glance. :)

clang/test/SemaCXX/coroutines.cpp

1127

Nit: Here and below, I'd be briefer.

[mizvekov]

@Quuxplusone Thank you for the review. All your points are good ones and will be addressed in time!

The new NRVO propagation test clang/test/CodeGen/nrvo-tracking.cpp is also breaking on the buildbot, but it works on my machine.
Will also take a look at that one.

clang/test/SemaCXX/conversion-function.cpp

160

Too bad you can't also define macros for these expected declarations :)

[mizvekov]

Just rebased, removing trailing whitespace noise.

Other review points to be addressed later.

[mizvekov]

clang/test/SemaCXX/conversion-function.cpp

160

From my reading of the code, only when compiling this source as not C++ (__cplusplus undefined).

And you made me realize I made a mistake there.

So remember this is called from -cc1, and when you don't pass "-std=c++" option to it, it looks like it does not actually set __cplusplus.

So yeah I unintentionally removed some test coverage there, which I will restore, thanks for catching this!

I will also look for if I have made any similar mistakes in other parts of this patch.

clang/test/SemaCXX/coroutine-rvo.cpp

41–45

So these are the changes I picked from D68845.

You were a reviewer, and you did not raise an objection there :)

Though that is perfectly fine, that was a couple of years back and our perceptions just change I guess.

Though once I have P2266 implementation rebased on top of this, I can see if this change still makes sense in our context, but I'd also like for @aaronpuchert to weight on this.

144

Like previous, you did not raise an objection on the original D68845 :)

But I agree with this change. But I'd like for @aaronpuchert to have a final say on this since these are his tests that I am merely taking, just so they do not sit there unused.

[mizvekov]

• Addresses most of Arthur's points.
• Re-adds test coverage for conversion-function.cpp and temp.mem/p5.cpp with no C++ version specified.
• Adds a couple more tests on nrvo-tracking for blocks returning references.

[mizvekov]

clang/test/SemaCXX/coroutine-rvo.cpp

41–45

I think I see why this change was made. Both in @aaronpuchert 's patch and in the P2266 implementation, we stop creating that (incorrect) temporary when passing value between co_return expression and return_value. A non-trivial value is a better test for the temporary, but it does not add anything to the case with no temporary.

So what I am going to do, is to move just this change to the P2266 implementation patch.

144

I will go ahead and make this change anyway, since he might be unavailable. We can always revert it if he comes back and raises an objection, I guess :)

[mizvekov]

• Finally addresses all of Arthur's review requests.

[• Quuxplusone]

There's unlikely to be any further substantive comments from me, and this basically LGTM (or, in the places it looks bad, it's just the pre-existing awfulness of how the Clang test suite is organized).
I think you need to either get someone's attention to approve this, or approve it yourself. :)

clang/test/SemaCXX/constant-expression-cxx11.cpp

393–406

I wonder if you ought to just leave this test alone. It's got cxx11 in the name of the test, and it does a lot of things that are deprecated in 20/2b which you're having to work around.
No strong opinion, but mainly because I haven't looked closely.
If your upcoming NRVO patches actually have some effect on constexpr evaluation, then perhaps it's time to add a separate constant-expression-cxx20.cpp. Or, split out the NRVO-specific parts of this one into a smaller simpler constexpr-copy-elision.cpp which runs in all modes, but leave the bulk of this file alone and C++11-only. WDYT?

Ooh, same comment about constant-expression-cxx(1y->14).cpp. I do see that as evidence in favor of adding a constant-expression-cxx20.cpp.

[thakis]

This looks fine to me. Maybe wait for a day or two to see if richardsmith wants to say anything, else this is good to go.

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx20 %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_14_17 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17 %s
 
 namespace test_delete_function {
 struct A1 {
   A1();
   A1(const A1 &);
   A1(A1 &&) = delete; // expected-note {{'A1' has been explicitly marked deleted here}}
 };
 A1 test1() {

 }
 } // namespace test_delete_function
 
 // In C++20, implicitly movable entity can be rvalue reference to non-volatile
 // automatic object.
 namespace test_implicitly_movable_rvalue_ref {
 struct A1 {
   A1(A1 &&);
-  A1(const A1 &) = delete; // cxx11_14_17-note {{'A1' has been explicitly marked deleted here}}
+  A1(const A1 &) = delete; // cxx11_17-note {{'A1' has been explicitly marked deleted here}}
 };
 A1 test1(A1 &&a) {
-  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::A1'}}
+  return a; // cxx11_17-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::A1'}}
 }
 
 struct A2 {
   A2(A2 &&);
 
 private:
-  A2(const A2 &); // cxx11_14_17-note {{declared private here}}
+  A2(const A2 &); // cxx11_17-note {{declared private here}}
 };
 A2 test2(A2 &&a) {
-  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::A2'}}
+  return a; // cxx11_17-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::A2'}}
 }
 
 struct B1 {
   B1(const B1 &);
-  B1(B1 &&) = delete; // cxx20-note {{'B1' has been explicitly marked deleted here}}
+  B1(B1 &&) = delete; // cxx20_2b-note {{'B1' has been explicitly marked deleted here}}
 };
 B1 test3(B1 &&b) {
-  return b; // cxx20-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
+  return b; // cxx20_2b-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
 }
 
 struct B2 {
   B2(const B2 &);
 
 private:
-  B2(B2 &&); // cxx20-note {{declared private here}}
+  B2(B2 &&); // cxx20_2b-note {{declared private here}}
 };
 B2 test4(B2 &&b) {
-  return b; // cxx20-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
+  return b; // cxx20_2b-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
 }
 } // namespace test_implicitly_movable_rvalue_ref
 
 // In C++20, operand of throw-expression can be function parameter or
 // catch-clause parameter.
 namespace test_throw_parameter {
 void func();
 
 struct A1 {
   A1(const A1 &);
-  A1(A1 &&) = delete; // cxx20-note {{'A1' has been explicitly marked deleted here}}
+  A1(A1 &&) = delete; // cxx20_2b-note {{'A1' has been explicitly marked deleted here}}
+  // expected-note@-1 {{'A1' has been explicitly marked deleted here}}
 };
 void test1() {
   try {
     func();
   } catch (A1 a) {
-    throw a; // cxx20-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+    throw a; // cxx20_2b-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
   }
 }
 
 struct A2 {
   A2(const A2 &);
 
 private:
-  A2(A2 &&); // cxx20-note {{declared private here}}
+  A2(A2 &&); // cxx20_2b-note {{declared private here}}
 };
 void test2() {
   try {
     func();
   } catch (A2 a) {
-    throw a; // cxx20-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
+    throw a; // cxx20_2b-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
   }
 }
+
+void test3(A1 a) try {
+  func();
+} catch (...) {
+  throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+}
 } // namespace test_throw_parameter
 
 // In C++20, during the first overload resolution, the selected function no
 // need to be a constructor.
 namespace test_non_ctor_conversion {
 class C {};
 
 struct A1 {
   operator C() &&;
-  operator C() const & = delete; // cxx11_14_17-note {{'operator C' has been explicitly marked deleted here}}
+  operator C() const & = delete; // cxx11_17-note {{'operator C' has been explicitly marked deleted here}}
 };
 C test1() {
   A1 a;
-  return a; // cxx11_14_17-error {{conversion function from 'test_non_ctor_conversion::A1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+  return a; // cxx11_17-error {{conversion function from 'test_non_ctor_conversion::A1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
 }
 
 struct A2 {
   operator C() &&;
 
 private:
-  operator C() const &; // cxx11_14_17-note {{declared private here}}
+  operator C() const &; // cxx11_17-note {{declared private here}}
 };
 C test2() {
   A2 a;
-  return a; // cxx11_14_17-error {{'operator C' is a private member of 'test_non_ctor_conversion::A2'}}
+  return a; // cxx11_17-error {{'operator C' is a private member of 'test_non_ctor_conversion::A2'}}
 }
 
 struct B1 {
   operator C() const &;
-  operator C() && = delete; // cxx20-note {{'operator C' has been explicitly marked deleted here}}
+  operator C() && = delete; // cxx20_2b-note {{'operator C' has been explicitly marked deleted here}}
 };
 C test3() {
   B1 b;
-  return b; // cxx20-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+  return b; // cxx20_2b-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
 }
 
 struct B2 {
   operator C() const &;
 
 private:
-  operator C() &&; // cxx20-note {{declared private here}}
+  operator C() &&; // cxx20_2b-note {{declared private here}}
 };
 C test4() {
   B2 b;
-  return b; // cxx20-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
+  return b; // cxx20_2b-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
 }
 } // namespace test_non_ctor_conversion
 
 // In C++20, during the first overload resolution, the first parameter of the
 // selected function no need to be an rvalue reference to the object's type.
 namespace test_ctor_param_rvalue_ref {
 struct A1;
 struct A2;
 struct B1;
 struct B2;
 
 struct NeedRvalueRef {
   NeedRvalueRef(A1 &&);
   NeedRvalueRef(A2 &&);
   NeedRvalueRef(B1 &&);
   NeedRvalueRef(B2 &&);
 };
 struct NeedValue {
-  NeedValue(A1); // cxx11_14_17-note 2 {{passing argument to parameter here}}
+  NeedValue(A1); // cxx11_17-note 2 {{passing argument to parameter here}}
   NeedValue(A2);
-  NeedValue(B1); // cxx20-note 2 {{passing argument to parameter here}}
+  NeedValue(B1); // cxx20_2b-note 2 {{passing argument to parameter here}}
   NeedValue(B2);
 };
 
 struct A1 {
   A1();
   A1(A1 &&);
-  A1(const A1 &) = delete; // cxx11_14_17-note 3 {{'A1' has been explicitly marked deleted here}}
+  A1(const A1 &) = delete; // cxx11_17-note 3 {{'A1' has been explicitly marked deleted here}}
 };
 NeedValue test_1_1() {
   // not rvalue reference
   // same type
   A1 a;
-  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
 }
 class DerivedA1 : public A1 {};
 A1 test_1_2() {
   // rvalue reference
   // not same type
   DerivedA1 a;
-  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
 }
 NeedValue test_1_3() {
   // not rvalue reference
   // not same type
   DerivedA1 a;
-  return a; // cxx11_14_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+  return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
 }
 
 struct A2 {
   A2();
   A2(A2 &&);
 
 private:
-  A2(const A2 &); // cxx11_14_17-note 3 {{declared private here}}
+  A2(const A2 &); // cxx11_17-note 3 {{declared private here}}
 };
 NeedValue test_2_1() {
   // not rvalue reference
   // same type
   A2 a;
-  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
 }
 class DerivedA2 : public A2 {};
 A2 test_2_2() {
   // rvalue reference
   // not same type
   DerivedA2 a;
-  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
 }
 NeedValue test_2_3() {
   // not rvalue reference
   // not same type
   DerivedA2 a;
-  return a; // cxx11_14_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+  return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
 }
 
 struct B1 {
   B1();
   B1(const B1 &);
-  B1(B1 &&) = delete; // cxx20-note 3 {{'B1' has been explicitly marked deleted here}}
+  B1(B1 &&) = delete; // cxx20_2b-note 3 {{'B1' has been explicitly marked deleted here}}
 };
 NeedValue test_3_1() {
   // not rvalue reference
   // same type
   B1 b;
-  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
 }
 class DerivedB1 : public B1 {};
 B1 test_3_2() {
   // rvalue reference
   // not same type
   DerivedB1 b;
-  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
 }
 NeedValue test_3_3() {
   // not rvalue reference
   // not same type
   DerivedB1 b;
-  return b; // cxx20-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+  return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
 }
 
 struct B2 {
   B2();
   B2(const B2 &);
 
 private:
-  B2(B2 &&); // cxx20-note 3 {{declared private here}}
+  B2(B2 &&); // cxx20_2b-note 3 {{declared private here}}
 };
 NeedValue test_4_1() {
   // not rvalue reference
   // same type
   B2 b;
-  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
 }
 class DerivedB2 : public B2 {};
 B2 test_4_2() {
   // rvalue reference
   // not same type
   DerivedB2 b;
-  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
 }
 NeedValue test_4_3() {
   // not rvalue reference
   // not same type
   DerivedB2 b;
-  return b; // cxx20-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+  return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
 }
 } // namespace test_ctor_param_rvalue_ref
 
 namespace test_lvalue_ref_is_not_moved_from {
 
 struct Target {};
   // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
   // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
-  // cxx11_14_17-note@-3 {{candidate constructor (the implicit copy constructor) not viable}}
-  // cxx11_14_17-note@-4 {{candidate constructor (the implicit move constructor) not viable}}
+  // cxx11_17-note@-3 {{candidate constructor (the implicit copy constructor) not viable}}
+  // cxx11_17-note@-4 {{candidate constructor (the implicit move constructor) not viable}}
 
 struct CopyOnly {
-  CopyOnly(CopyOnly&&) = delete; // cxx20-note {{has been explicitly marked deleted here}}
+  CopyOnly(CopyOnly&&) = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
   CopyOnly(CopyOnly&);
-  operator Target() && = delete; // cxx20-note {{has been explicitly marked deleted here}}
+  operator Target() && = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
   operator Target() &;
 };
 
 struct MoveOnly {
   MoveOnly(MoveOnly&&); // expected-note {{copy constructor is implicitly deleted because}}
-    // cxx11_14_17-note@-1 {{copy constructor is implicitly deleted because}}
+    // cxx11_17-note@-1 {{copy constructor is implicitly deleted because}}
   operator Target() &&; // expected-note {{candidate function not viable}}
-    // cxx11_14_17-note@-1 {{candidate function not viable}}
+    // cxx11_17-note@-1 {{candidate function not viable}}
 };
 
 extern CopyOnly copyonly;
 extern MoveOnly moveonly;
 
 CopyOnly t1() {
     CopyOnly& r = copyonly;
     return r;
 }
 
 CopyOnly t2() {
     CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
-    return r; // cxx20-error {{call to deleted constructor}}
+    return r; // cxx20_2b-error {{call to deleted constructor}}
 }
 
 MoveOnly t3() {
     MoveOnly& r = moveonly;
     return r; // expected-error {{call to implicitly-deleted copy constructor}}
 }
 
 MoveOnly t4() {
     MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
-    return r; // cxx11_14_17-error {{call to implicitly-deleted copy constructor}}
+    return r; // cxx11_17-error {{call to implicitly-deleted copy constructor}}
 }
 
 Target t5() {
     CopyOnly& r = copyonly;
     return r;
 }
 
 Target t6() {
     CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
-    return r; // cxx20-error {{invokes a deleted function}}
+    return r; // cxx20_2b-error {{invokes a deleted function}}
 }
 
 Target t7() {
     MoveOnly& r = moveonly;
     return r; // expected-error {{no viable conversion}}
 }
 
 Target t8() {
     MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
-    return r; // cxx11_14_17-error {{no viable conversion}}
+    return r; // cxx11_17-error {{no viable conversion}}
 }
 
 } // namespace test_lvalue_ref_is_not_moved_from
 
 namespace test_rvalue_ref_to_nonobject {
 
 struct CopyOnly {};
 struct MoveOnly {};

 }
 
 Target t4() {
     MoveOnly (&&r)() = static_cast<MoveOnly(&&)()>(make_moveonly);
     return r; // expected-error {{invokes a deleted function}}
 }
 
 } // namespace test_rvalue_ref_to_nonobject
+
+namespace test_simpler_implicit_move {
+
+struct CopyOnly {
+  CopyOnly();
+  CopyOnly(CopyOnly &);
+};
+struct MoveOnly {
+  MoveOnly();
+  MoveOnly(MoveOnly &&);
+};
+MoveOnly &&rref();
+
+MoveOnly &&test1(MoveOnly &&w) {
+  return w; // expected-error {{cannot bind to lvalue of type}}
+}
+
+CopyOnly test2(bool b) {
+  static CopyOnly w1;
+  CopyOnly w2;
+  if (b) {
+    return w1;
+  } else {
+    return w2;
+  }
+}
+
+template <class T> T &&test3(T &&x) { return x; } // expected-error {{cannot bind to lvalue of type}}
+template MoveOnly& test3<MoveOnly&>(MoveOnly&);
+template MoveOnly&& test3<MoveOnly>(MoveOnly&&); // expected-note {{in instantiation of function template specialization}}
+
+MoveOnly &&test4() {
+  MoveOnly &&x = rref();
+  return x; // expected-error {{cannot bind to lvalue of type}}
+}
+
+void test5() try {
+  CopyOnly x;
+  throw x;
+} catch (...) {
+}
+
+} // namespace test_simpler_implicit_move

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

-// RUN: %clang_cc1 -verify -std=c++1y %s
+// RUN: %clang_cc1 -verify -std=c++2b -verify %s
+// RUN: %clang_cc1 -verify -std=c++20 -verify %s
+// RUN: %clang_cc1 -verify -std=c++14 -verify %s
 
 namespace std {
   template<typename T> struct initializer_list {
     const T *p;
     unsigned long n;
     initializer_list(const T *p, unsigned long n);
   };
 }

clang/test/CXX/drs/dr3xx.cpp

-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2b -verify=expected,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 
 namespace dr300 { // dr300: yes
   template<typename R, typename A> void f(R (&)(A)) {}
   int g(int);
   void h() { f(g); }
 }
 
 namespace dr301 { // dr301: yes
   // see also dr38
   struct S;
   template<typename T> void operator+(T, T);
   void operator-(S, S);
 
   void f() {
     bool a = (void(*)(S, S))operator+<S> <
              (void(*)(S, S))operator+<S>;
-    bool b = (void(*)(S, S))operator- <
-             (void(*)(S, S))operator-;
+    bool b = (void(*)(S, S))operator- < // cxx20_2b-note {{to match this '<'}}
+             (void(*)(S, S))operator-; // cxx20_2b-error {{expected '>'}}
     bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}}
              (void(*)(S, S))operator-; // expected-error {{expected '>'}}
   }
 
   template<typename T> void f() {
     typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
     // FIXME: This shouldn't say (null).
     class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}

 namespace dr331 { // dr331: yes
   struct A {
     A(volatile A&); // expected-note 2{{candidate}}
   } const a, b(a); // expected-error 2{{no matching constructor}}
 }
 
 namespace dr332 { // dr332: dup 577
   void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}}
+  // cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
   void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}}
   void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}}
+  // cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
 }
 
 namespace dr333 { // dr333: yes
   int n = 0;
   int f(int(n));
   int g((int(n)));
   int h = f(g);
 }
#if __cplusplus < 201103L
   // expected-error@-4 2{{variable length array}}
   // expected-error@-3 2{{variable length array}}
 #endif
 }
 
 namespace dr368 { // dr368: yes
   template<typename T, T> struct S {}; // expected-note {{here}}
   template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
-  template<typename T> int g(S<T, (T())> *); // expected-note {{type 'dr368::X'}}
-  template<typename T> int g(S<T, true ? T() : T()> *); // expected-note {{type 'dr368::X'}}
+  template<typename T> int g(S<T, (T())> *); // cxx98_17-note {{type 'dr368::X'}}
+  // cxx20_2b-note@-1 {{candidate function [with T = dr368::X]}}
+  template<typename T> int g(S<T, true ? T() : T()> *); // cxx98_17-note {{type 'dr368::X'}}
+  // cxx20_2b-note@-1 {{candidate function [with T = dr368::X]}}
   struct X {};
-  int n = g<X>(0); // expected-error {{no matching}}
+  int n = g<X>(0); // cxx98_17-error {{no matching}}
+  // cxx20_2b-error@-1 {{call to 'g' is ambiguous}}
 }
 
 // dr370: na
 
 namespace dr372 { // dr372: no
   namespace example1 {
     template<typename T> struct X {
     protected:
namespace dr384 { // dr384: yes
 
   int main() {
     N1::X<N2::Z> v;
     v.f(0);
   }
 }
 
 namespace dr385 { // dr385: yes
-  struct A { protected: void f(); }; 
+  struct A { protected: void f(); };
   struct B : A { using A::f; };
   struct C : A { void g(B b) { b.f(); } };
   void h(B b) { b.f(); }
 
   struct D { int n; }; // expected-note {{member}}
   struct E : protected D {}; // expected-note {{protected}}
   struct F : E { friend int i(E); };
   int i(E e) { return e.n; } // expected-error {{protected member}}

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-cxx14.cpp

-// RUN: %clang_cc1 -fsyntax-only -std=c++1y %s -verify
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
 
 int a;
 int &b = [] (int &r) -> decltype(auto) { return r; } (a);
 int &c = [] (int &r) -> decltype(auto) { return (r); } (a);
 int &d = [] (int &r) -> auto & { return r; } (a);
 int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}}
 
-
-int test_explicit_auto_return() 
+int test_explicit_auto_return()
 {
     struct X {};
     auto L = [](auto F, auto a) { return F(a); };
     auto M = [](auto a) -> auto { return a; }; // OK
     auto MRef = [](auto b) -> auto& { return b; }; //expected-warning{{reference to stack}}
     auto MPtr = [](auto c) -> auto* { return &c; }; //expected-warning{{address of stack}}
     auto MDeclType = [](auto&& d) -> decltype(auto) { return static_cast<decltype(d)>(d); }; //OK
     M(3);
-    
     auto &&x = MDeclType(X{});
     auto &&x1 = M(X{});
     auto &&x2 = MRef(X{});//expected-note{{in instantiation of}}
     auto &&x3 = MPtr(X{}); //expected-note{{in instantiation of}}
-    return 0;    
+    return 0;
 }
 
-int test_implicit_auto_return() 
-{  
+int test_implicit_auto_return()
+{
   {
     auto M = [](auto a) { return a; };
     struct X {};
     X x = M(X{});
-    
   }
 }
- 
 int test_multiple_returns()  {
-    auto M = [](auto a) { 
+    auto M = [](auto a) {
       bool k;
       if (k)
         return a;
       else
         return 5; //expected-error{{deduced as 'int' here}}
-    }; 
+    };
     M(3); // OK
     M('a'); //expected-note{{in instantiation of}}
   return 0;
 }
 int test_no_parameter_list()
 {
   static int si = 0;
     auto M = [] { return 5; }; // OK
     auto M2 = [] -> auto && { return si; };
 #if __cplusplus <= 202002L
       // expected-warning@-2{{is a C++2b extension}}
 #endif
     M();
 }
 
 int test_conditional_in_return() {
-  auto Fac = [](auto f, auto n) { 
+  auto Fac = [](auto f, auto n) {
     return n <= 0 ? n : f(f, n - 1) * n;
   };
   // FIXME: this test causes a recursive limit - need to error more gracefully.
   //Fac(Fac, 3);
 
-}
+}
 

clang/test/CXX/special/class.copy/p3-cxx11.cpp

+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++2b -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++20 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fsyntax-only -verify %s
 class X {
   X(const X&);
 
 public:
   X();
   X(X&&);
 };
 
 X return_by_move(int i, X x) {
   X x2;
   if (i == 0)
     return x;
   else if (i == 1)
     return x2;
   else
     return x;
 }
 
 void throw_move_only(X x) {
   X x2;
   throw x;
   throw x2;
 }
-  
 namespace PR10142 {
   struct X {
     X();
     X(X&&);
     X(const X&) = delete; // expected-note 2{{'X' has been explicitly marked deleted here}}
   };
 
   void f(int i) {

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-struct A { 
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify %s
+
+struct A {
   template <class T> operator T*();
-}; 
+};
 
 template <class T> A::operator T*() { return 0; }
 template <> A::operator char*(){ return 0; } // specialization
 template A::operator void*(); // explicit instantiation
 
-int main() { 
+int main() {
   A a;
-  int *ip; 
+  int *ip;
   ip = a.operator int*();
 }
 
 // PR5742
 namespace PR5742 {
   template <class T> struct A { };
   template <class T> struct B { };
 
   struct S {
     template <class T> operator T();
   } s;
 
   void f() {
     s.operator A<A<int> >();
     s.operator A<B<int> >();
     s.operator A<B<A<int> > >();
   }
 }
 
 // PR5762
 class Foo {
  public:
   template <typename T> operator T();
-  
   template <typename T>
   T As() {
     return this->operator T();
   }
 
   template <typename T>
   T As2() {
     return operator T();
   }
-  
   int AsInt() {
     return this->operator int();
   }
 };
 
 template float Foo::As();
 template double Foo::As2();
 
 // Partial ordering with conversion function templates.
 struct X0 {
   template<typename T> operator T*() {
     T x = 1; // expected-note{{variable 'x' declared const here}}
     x = 17; // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}
   }
-  
   template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}}
-  
   template<typename T> operator const T*() const {
     T x = T();
     return x; // expected-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
     // expected-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}}
   }
 };
 
 template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}}

clang/test/CodeGen/nrvo-tracking.cpp

+// RUN: %clang_cc1 -std=c++20 -fblocks -Wno-return-stack-address -triple %itanium_abi_triple -emit-llvm -O1 -fexperimental-new-pass-manager -o - %s | FileCheck %s
+
+struct X {
+    X();
+    X(const X&);
+    X(X&&);
+};
+
+#define L(A, B, C) void l##A() {    \
+  auto t = []<class T = X>() -> C { \
+    T t;                            \
+    return B;                       \
+  }();                              \
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z2l1v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(1, t, X);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l2v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(2, t, X&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l3v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(3, t, T);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l4v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(4, t, T&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l5v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(5, t, auto);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l6v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(6, t, auto&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2l7v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(7, t, decltype(auto));
+
+// CHECK-LABEL: define{{.*}} void @_Z2l8v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+L(8, (t), decltype(auto));
+
+#undef L
+
+#define F(A, B, C) template<class T = X> static inline auto tf##A() -> C { \
+    T t;                                                                   \
+    return B;                                                              \
+}                                                                          \
+void f##A() { auto t = tf##A(); }                                          \
+
+// CHECK-LABEL: define{{.*}} void @_Z2f1v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(1, t, X);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f2v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(2, t, X&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f3v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(3, t, T);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f4v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(4, t, T&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f5v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(5, t, auto);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f6v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(6, t, auto&);
+
+// CHECK-LABEL: define{{.*}} void @_Z2f7v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(7, t, decltype(auto));
+
+// CHECK-LABEL: define{{.*}} void @_Z2f8v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1ERKS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+F(8, (t), decltype(auto));
+
+#undef F
+
+#define B(A, B) void b##A() { \
+  auto t = []<class T = X>() { return ^ B () { \
+      T t;                                     \
+      return t;                                \
+  }; }()();                                    \
+}
+
+//B(1, X); // Uncomment this line at your own peril ;)
+
+// CHECK-LABEL: define{{.*}} void @"___ZZ2b2v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+B(2, T);
+
+// CHECK-LABEL: define{{.*}} void @"___ZZ2b3v
+// CHECK:       call {{.*}} @_ZN1XC1Ev
+// CHECK-NEXT:  call {{.*}} @_ZN1XC1EOS_
+// CHECK-NEXT:  call void @llvm.lifetime.end
+// CHECK-NEXT:  ret void
+B(3, );
+
+#undef B

clang/test/SemaCXX/P1155.cpp

-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=cxx20 %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=cxx11_14_17 %s
-// cxx20-no-diagnostics
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
+// cxx20_2b-no-diagnostics
 
 // Throwing
 namespace test_throwing {
 class Widget {
 public:
   Widget(Widget &&);
   Widget(const Widget &) = delete;
 };
 
 void seven(Widget w) {
   throw w; // Clang already do this implicit move before -std=c++20
 }
 } // namespace test_throwing
 
 // Non-constructor conversion
 namespace test_non_constructor_conversion {
 class Widget {};
 
 struct To {
-  operator Widget() const & = delete; // cxx11_14_17-note {{'operator Widget' has been explicitly marked deleted here}}
+  operator Widget() const & = delete; // cxx11_17-note {{'operator Widget' has been explicitly marked deleted here}}
   operator Widget() &&;
 };
 
 Widget nine() {
   To t;
-  return t; // cxx11_14_17-error {{conversion function from 'test_non_constructor_conversion::To' to 'test_non_constructor_conversion::Widget' invokes a deleted function}}
+  return t; // cxx11_17-error {{conversion function from 'test_non_constructor_conversion::To' to 'test_non_constructor_conversion::Widget' invokes a deleted function}}
 }
 } // namespace test_non_constructor_conversion
 
 // By-value sinks
 namespace test_by_value_sinks {
 class Widget {
 public:
   Widget();
   Widget(Widget &&);
-  Widget(const Widget &) = delete; // cxx11_14_17-note {{'Widget' has been explicitly marked deleted here}}
+  Widget(const Widget &) = delete; // cxx11_17-note {{'Widget' has been explicitly marked deleted here}}
 };
 
 struct Fowl {
-  Fowl(Widget); // cxx11_14_17-note {{passing argument to parameter here}}
+  Fowl(Widget); // cxx11_17-note {{passing argument to parameter here}}
 };
 
 Fowl eleven() {
   Widget w;
-  return w; // cxx11_14_17-error {{call to deleted constructor of 'test_by_value_sinks::Widget'}}
+  return w; // cxx11_17-error {{call to deleted constructor of 'test_by_value_sinks::Widget'}}
 }
 } // namespace test_by_value_sinks
 
 // Slicing
 namespace test_slicing {
 class Base {
 public:
   Base();
   Base(Base &&);
-  Base(Base const &) = delete; // cxx11_14_17-note {{'Base' has been explicitly marked deleted here}}
+  Base(Base const &) = delete; // cxx11_17-note {{'Base' has been explicitly marked deleted here}}
 };
 
 class Derived : public Base {};
 
 Base thirteen() {
   Derived result;
-  return result; // cxx11_14_17-error {{call to deleted constructor of 'test_slicing::Base'}}
+  return result; // cxx11_17-error {{call to deleted constructor of 'test_slicing::Base'}}
 }
 } // namespace test_slicing

clang/test/SemaCXX/constant-expression-cxx11.cpp

-// RUN: %clang_cc1 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
 
 namespace StaticAssertFoldTest {
 
 int x;
 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
+// cxx20_2b-note@-1 {{cannot modify an object that is visible outside that expression}}
 static_assert(false, "test"); // expected-error {{test}}
 
 }
 
 typedef decltype(sizeof(char)) size_t;
 
 template<typename T> constexpr T id(const T &t) { return t; }
 template<typename T> constexpr T min(const T &a, const T &b) {

 static_assert(&x == &x, "");
 static_assert(&x != &x, "false"); // expected-error {{false}}
 static_assert(&x <= &x, "");
 static_assert(&x >= &x, "");
 static_assert(&x < &x, "false"); // expected-error {{false}}
 static_assert(&x > &x, "false"); // expected-error {{false}}
 
 constexpr S* sptr = &s;
-constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
+constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // cxx11-error {{constant expression}} cxx11-note {{dynamic_cast}}
 
 struct U {};
 struct Str {
   int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \
-    expected-warning {{not an integral constant expression}} \
-    expected-note {{dynamic_cast is not allowed in a constant expression}}
+    cxx11-warning {{not an integral constant expression}} \
+    cxx11-note {{dynamic_cast is not allowed in a constant expression}}
   int b : reinterpret_cast<S*>(sptr) == reinterpret_cast<S*>(sptr); // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{reinterpret_cast is not allowed in a constant expression}}
   int c : (S*)(long)(sptr) == (S*)(long)(sptr); // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
   int d : (S*)(42) == (S*)(42); // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
   int e : (Str*)(sptr) == (Str*)(sptr); // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
   int f : &(U&)(*sptr) == &(U&)(*sptr); // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
   int g : (S*)(void*)(sptr) == sptr; // \
     expected-warning {{not an integral constant expression}} \
     expected-note {{cast from 'void *' is not allowed in a constant expression}}
 };
 
 extern char externalvar[];
 constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} expected-note {{reinterpret_cast}}
 constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}}
+// cxx20_2b-warning@-1 {{comparison between two arrays is deprecated}}
 static_assert(0 != "foo", "");
 
 }
 
 namespace MaterializeTemporary {
 
 constexpr int f(const int &r) { return r; }
 constexpr int n = f(1);
void foo() {
   constexpr static B b1 { { 1 }, { 2 } }; // ok
   constexpr thread_local B b2 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
   constexpr B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
 }
 
 constexpr B &&b4 = ((1, 2), 3, 4, B { {10}, {{20}} });
 static_assert(&b4 != &b2, "");
 
 // Proposed DR: copy-elision doesn't trigger lifetime extension.
-// expected-warning@+1 2{{temporary whose address is used as value of local variable 'b5' will be destroyed at the end of the full-expression}}
+// cxx11-warning@+1 2{{temporary whose address is used as value of local variable 'b5' will be destroyed at the end of the full-expression}}
 constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
 
 namespace NestedNonStatic {
   // Proposed DR: for a reference constant expression to refer to a static
   // storage duration temporary, that temporary must itself be initialized
   // by a constant expression (a core constant expression is not enough).
   struct A { int &&r; };
   struct B { A &&a; };
   constexpr B a = { A{0} }; // ok
-  // expected-warning@+1 {{temporary bound to reference member of local variable 'b' will be destroyed at the end of the full-expression}}
-  constexpr B b = { A(A{0}) }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
+  // cxx11-warning@+1 {{temporary bound to reference member of local variable 'b' will be destroyed at the end of the full-expression}}
+  constexpr B b = { A(A{0}) }; // cxx11-error {{constant expression}} cxx11-note {{reference to temporary}} cxx11-note {{here}}
 }
 
 namespace FakeInitList {
   struct init_list_3_ints { const int (&x)[3]; };
   struct init_list_2_init_list_3_ints { const init_list_3_ints (&x)[2]; };
   constexpr init_list_2_init_list_3_ints ils = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
 }
 
 namespace ConstAddedByReference {
void test0() {
     struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
     Y y;
     auto& b = y.b;
   }
 }
 
 namespace NamespaceAlias {
   constexpr int f() {
-    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++14 extension}}
+    namespace NS = NamespaceAlias; // cxx11-warning {{use of this statement in a constexpr function is a C++14 extension}}
     return &NS::f != nullptr;
   }
 }
 
 // Constructors can be implicitly constexpr, even for a non-literal type.
 namespace ImplicitConstexpr {
   struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
   struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
namespace TLS {
   constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
   constexpr bool c = f() == f();
 
   constexpr int *g() { return &m; }
   constexpr int *r = g();
 }
 
 namespace Void {
-  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
+  constexpr void f() { return; } // cxx11-error{{constexpr function's return type 'void' is not a literal type}}
 
   void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
 #define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
   template<typename T, size_t S>
   constexpr T get(T (&a)[S], size_t k) {
     return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
   }
 #undef ASSERT
   template int get(int (&a)[4], size_t);
   constexpr int arr[] = { 4, 1, 2, 3, 4 };
   static_assert(get(arr, 1) == 1, "");
   static_assert(get(arr, 4) == 4, "");
   static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
   // expected-note{{in call to 'get(arr, 0)'}}
 }
 
 namespace std { struct type_info; }
 
 namespace TypeId {
   struct A { virtual ~A(); };
   A f();
-  A &g();
+  A &g(); // cxx20_2b-note {{declared here}}
   constexpr auto &x = typeid(f());
-  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
-  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}} \
-  // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
+  constexpr auto &y = typeid(g()); // expected-error{{constant expression}}
+  // cxx11-note@-1 {{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}}
+  // expected-warning@-2 {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
+  // cxx20_2b-note@-3 {{non-constexpr function 'g' cannot be used in a constant expression}}
 }
 
 namespace PR14203 {
   struct duration {
     constexpr duration() {}
     constexpr operator int() const { return 0; }
   };
   // These are valid per P0859R0 (moved as DR).
struct S1 {
     virtual int f() const;
   };
   struct S2 {
     virtual int f();
   };
   template <typename T> struct X : T {
     constexpr X() {}
     double d = 0.0;
-    constexpr int f() { return sizeof(T); } // expected-warning {{will not be implicitly 'const' in C++14}}
+    constexpr int f() { return sizeof(T); } // cxx11-warning {{will not be implicitly 'const' in C++14}}
   };
 
   // Virtual f(), not OK.
   constexpr X<X<S1>> xxs1;
   constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1);
-  static_assert(p->f() == sizeof(X<S1>), ""); // expected-error {{constant expression}} expected-note {{virtual function}}
+  static_assert(p->f() == sizeof(X<S1>), ""); // cxx11-error {{constant expression}} cxx11-note {{virtual function}}
+  // cxx20_2b-error@-1 {{static_assert failed}}
 
   // Non-virtual f(), OK.
   constexpr X<X<S2>> xxs2;
   constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
-  static_assert(q->f() == sizeof(S2), "");
+  static_assert(q->f() == sizeof(S2), ""); // cxx20_2b-error {{static_assert failed}}
 }
 
 namespace ConstexprConstructorRecovery {
   class X {
   public:
       enum E : short {
           headers = 0x1,
           middlefile = 0x2,
           choices = 0x4
       };
       constexpr X() noexcept {};
   protected:
-      E val{0}; // expected-error {{cannot initialize a member subobject of type 'ConstexprConstructorRecovery::X::E' with an rvalue of type 'int'}} expected-note {{here}}
+      E val{0}; // cxx11-error {{cannot initialize a member subobject of type 'ConstexprConstructorRecovery::X::E' with an rvalue of type 'int'}} cxx11-note {{here}}
   };
   // FIXME: We should avoid issuing this follow-on diagnostic.
-  constexpr X x{}; // expected-error {{constant expression}} expected-note {{not initialized}}
+  constexpr X x{}; // cxx11-error {{constant expression}} cxx11-note {{not initialized}}
 }
 
 namespace Lifetime {
   void f() {
     constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}}
     constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}}
   }
 
namespace PR21859 {
   template <typename T> constexpr int FunT1() { return; } // expected-error {{non-void constexpr function 'FunT1' should return a value}}
   template <typename T> constexpr int FunT2() { return 0; }
   template <> constexpr int FunT2<double>() { return 0; }
   template <> constexpr int FunT2<int>() { return; } // expected-error {{non-void constexpr function 'FunT2<int>' should return a value}}
 }
 
 struct InvalidRedef {
   int f; // expected-note{{previous definition is here}}
-  constexpr int f(void); // expected-error{{redefinition of 'f'}} expected-warning{{will not be implicitly 'const'}}
+  constexpr int f(void); // expected-error{{redefinition of 'f'}} cxx11-warning{{will not be implicitly 'const'}}
 };
 
 namespace PR17938 {
   template <typename T> constexpr T const &f(T const &x) { return x; }
 
   struct X {};
   struct Y : X {};
   struct Z : Y { constexpr Z() {} };
namespace InheritedCtor {
 
   struct B : A { int n; using A::A; }; // expected-note {{here}}
   constexpr B b(0); // expected-error {{constant expression}} expected-note {{derived class}}
 
   struct C : A { using A::A; struct { union { int n, m = 0; }; union { int a = 0; }; int k = 0; }; struct {}; union {}; }; // expected-warning 6{{}}
   constexpr C c(0);
 
   struct D : A {
-    using A::A; // expected-note {{here}}
+    using A::A; // cxx11-note {{here}}
     struct { // expected-warning {{extension}}
       union { // expected-warning {{extension}}
         int n;
       };
     };
   };
-  constexpr D d(0); // expected-error {{constant expression}} expected-note {{derived class}}
+  constexpr D d(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}}
 
   struct E : virtual A { using A::A; }; // expected-note {{here}}
+  // cxx20_2b-note@-1 {{struct with virtual base class is not a literal type}}
   // We wrap a function around this to avoid implicit zero-initialization
   // happening first; the zero-initialization step would produce the same
   // error and defeat the point of this test.
   void f() {
-    constexpr E e(0); // expected-error {{constant expression}} expected-note {{derived class}}
+    constexpr E e(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}}
+    // cxx20_2b-error@-1 {{constexpr variable cannot have non-literal type}}
   }
   // FIXME: This produces a note with no source location.
   //constexpr E e(0);
 
   struct W { constexpr W(int n) : w(n) {} int w; };
   struct X : W { using W::W; int x = 2; };
   struct Y : X { using X::X; int y = 3; };
   struct Z : Y { using Y::Y; int z = 4; };

clang/test/SemaCXX/constant-expression-cxx14.cpp

-// RUN: %clang_cc1 -std=c++1y -verify %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -triple=x86_64-linux-gnu
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s -fcxx-exceptions -triple=x86_64-linux-gnu
 
 struct S {
   // dummy ctor to make this a literal type
   constexpr S(int);
 
   S();
 
   int arr[10];
namespace subobject {
   struct C : B {};
   union D { constexpr D() : c() {} constexpr D(int n) : n(n) {} C c; int n; };
   constexpr void f(D &d) {
     d.c.a.y = 3;
     // expected-note@-1 {{cannot modify an object that is visible outside}}
     // expected-note@-2 {{assignment to member 'c' of union with active member 'n'}}
   }
   constexpr bool check(D &d) { return d.c.a.y == 3; }
+  // cxx20_2b-note@-1 {{read of member 'y' of union with active member 'x' is not allowed in a constant expression}}
 
   constexpr bool g() { D d; f(d); return d.c.a.y == 3; }
   static_assert(g(), "");
 
   D d;
   constexpr bool h() { f(d); return check(d); } // expected-note {{in call}}
   static_assert(h(), ""); // expected-error {{constant expression}} expected-note {{in call}}
 
   constexpr bool i() { D d(0); f(d); return check(d); } // expected-note {{in call}}
   static_assert(i(), ""); // expected-error {{constant expression}} expected-note {{in call}}
 
-  constexpr bool j() { D d; d.c.a.x = 3; return check(d); } // expected-note {{assignment to member 'x' of union with active member 'y'}}
+  constexpr bool j() { D d; d.c.a.x = 3; return check(d); } // cxx14-note {{assignment to member 'x' of union with active member 'y'}}
+  // cxx20_2b-note@-1 {{in call to 'check(d)'}}
   static_assert(j(), ""); // expected-error {{constant expression}} expected-note {{in call}}
 }
 
 namespace lifetime {
   constexpr int &&id(int &&n) { return static_cast<int&&>(n); }
   constexpr int &&dead() { return id(0); } // expected-note {{temporary created here}}
   constexpr int bad() { int &&n = dead(); n = 1; return n; } // expected-note {{assignment to temporary whose lifetime has ended}}
   static_assert(bad(), ""); // expected-error {{constant expression}} expected-note {{in call}}
namespace incdec {
   constexpr int overflow_int_inc_2 = ++ref(0x7fffffff); // expected-error {{constant}} expected-note {{2147483648}}
   constexpr int overflow_int_inc_2_ok = ++ref(0x7ffffffe);
 
   // inc/dec on short can't overflow because we promote to int first
   static_assert(++ref<short>(0x7fff) == (int)0xffff8000u, "");
   static_assert(--ref<short>(0x8000) == 0x7fff, "");
 
   // inc on bool sets to true
-  static_assert(++ref(false), ""); // expected-warning {{deprecated}}
-  static_assert(++ref(true), ""); // expected-warning {{deprecated}}
+  static_assert(++ref(false), ""); // cxx14-warning {{deprecated}}
+  // cxx20_2b-error@-1 {{ISO C++17 does not allow incrementing expression of type bool}}
+  static_assert(++ref(true), ""); // cxx14-warning {{deprecated}}
+  // cxx20_2b-error@-1 {{ISO C++17 does not allow incrementing expression of type bool}}
 
   int arr[10];
   static_assert(++ref(&arr[0]) == &arr[1], "");
   static_assert(++ref(&arr[9]) == &arr[10], "");
   static_assert(++ref(&arr[10]) == &arr[11], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
   static_assert(ref(&arr[0])++ == &arr[0], "");
   static_assert(ref(&arr[10])++ == &arr[10], ""); // expected-error {{constant}} expected-note {{cannot refer to element 11}}
   static_assert(postinc(&arr[0]) == &arr[1], "");
namespace incdec {
   union U {
     int a, b;
   };
   constexpr int f(U u) {
     return ++u.b; // expected-note {{increment of member 'b' of union with active member 'a'}}
   }
   constexpr int wrong_member = f({0}); // expected-error {{constant}} expected-note {{in call to 'f({.a = 0})'}}
   constexpr int vol = --ref<volatile int>(0); // expected-error {{constant}} expected-note {{decrement of volatile-qualified}}
+  // cxx20_2b-warning@-1 {{decrement of object of volatile-qualified type 'volatile int' is deprecated}}
 
   constexpr int incr(int k) {
     int x = k;
     if (x++ == 100)
       return x;
     return incr(x);
   }
   static_assert(incr(0) == 101, "");
namespace VirtualFromBase {
   // Non-virtual f(), OK.
   constexpr X<X<S1>> xxs1;
   constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1);
   static_assert(p->f() == sizeof(S1), "");
 
   // Virtual f(), not OK.
   constexpr X<X<S2>> xxs2;
   constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
-  static_assert(q->f() == sizeof(X<S2>), ""); // expected-error {{constant expression}} expected-note {{virtual function}}
+  static_assert(q->f() == sizeof(X<S2>), ""); // cxx14-error {{constant expression}} cxx14-note {{virtual function}}
 }
 
 namespace Lifetime {
   constexpr int &get(int &&r) { return r; }
   constexpr int f() {
     int &r = get(123);
     return r; // expected-note {{read of object outside its lifetime}}
   }

 }
 
 namespace IndirectFields {
 
 // Reference indirect field.
 struct A {
   struct {
     union {
-      int x = x = 3; // expected-note {{outside its lifetime}}
+      int x = x = 3; // cxx14-note {{outside its lifetime}}
     };
   };
   constexpr A() {}
 };
-static_assert(A().x == 3, ""); // expected-error{{not an integral constant expression}} expected-note{{in call to 'A()'}}
+static_assert(A().x == 3, ""); // cxx14-error{{not an integral constant expression}} cxx14-note{{in call to 'A()'}}
 
 // Reference another indirect field, with different 'this'.
 struct B {
   struct {
     union {
       int x = 3;
     };
     int y = x;

clang/test/SemaCXX/conversion-function.cpp

-// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify %s 
-// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++98 %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++11 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected          -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected          -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
 
-class X { 
+class X {
 public:
   operator bool();
   operator int() const;
 
   bool f() {
     return operator bool();
   }
 

 typedef int array_type[10];
 
 class Y {
 public:
   void operator bool(int, ...) const; // expected-error{{conversion function cannot have a return type}} \
   // expected-error{{conversion function cannot have any parameters}}
 
   operator bool(int a = 4, int b = 6) const; // expected-error{{conversion function cannot have any parameters}}
-  
-  
   operator float(...) const;  // expected-error{{conversion function cannot be variadic}}
-  
-  
   operator func_type(); // expected-error{{conversion function cannot convert to a function type}}
   operator array_type(); // expected-error{{conversion function cannot convert to an array type}}
 };
 
 
 typedef int INT;
 typedef INT* INT_PTR;
 
-class Z { 
+class Z {
   operator int(); // expected-note {{previous declaration is here}}
   operator int**(); // expected-note {{previous declaration is here}}
-  
   operator INT();  // expected-error{{conversion function cannot be redeclared}}
   operator INT_PTR*(); // expected-error{{conversion function cannot be redeclared}}
 };
 
 
 class A { };
 
 class B : public A {

 
 C::operator const char*() const { return 0; }
 
 void f(const C& c) {
   const char* v = c;
 }
 
 // Test. Conversion in base class is visible in derived class.
-class XB { 
+class XB {
 public:
   operator int(); // expected-note {{candidate function}}
 };
 
-class Yb : public XB { 
+class Yb : public XB {
 public:
   operator char(); // expected-note {{candidate function}}
 };
 
 void f(Yb& a) {
   if (a) { } // expected-error {{conversion from 'Yb' to 'bool' is ambiguous}}
   int i = a; // OK. calls XB::operator int();
   char ch = a;  // OK. calls Yb::operator char();
 }
 
 // Test conversion + copy construction.
 class AutoPtrRef { };
 
 class AutoPtr {
-  AutoPtr(AutoPtr &); // expected-note{{declared private here}}
-  
+  AutoPtr(AutoPtr &); // cxx98_14-note{{declared private here}}
 public:
   AutoPtr();
   AutoPtr(AutoPtrRef);
-  
   operator AutoPtrRef();
 };
 
 AutoPtr make_auto_ptr();
 
 AutoPtr test_auto_ptr(bool Cond) {
   AutoPtr p1( make_auto_ptr() );
-  
   AutoPtr p;
   if (Cond)
-    return p; // expected-error{{calling a private constructor}}
-  
+    return p; // cxx98_14-error{{calling a private constructor}}
   return AutoPtr();
 }
 
 struct A1 {
   A1(const char *);
   ~A1();
 
 private:
-  A1(const A1&); // expected-note 2 {{declared private here}}
+  A1(const A1&); // cxx98_14-note 2 {{declared private here}}
 };
 
 A1 f() {
   // FIXME: redundant diagnostics!
-  return "Hello"; // expected-error {{calling a private constructor}}
+  return "Hello"; // cxx98_14-error {{calling a private constructor}}
 #if __cplusplus <= 199711L
   // expected-warning@-2 {{an accessible copy constructor}}
 #else
-  // expected-warning@-4 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
+  // cxx98_14-warning@-4 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
 #endif
 }
 
 namespace source_locations {
   template<typename T>
   struct sneaky_int {
     typedef int type;
   };
namespace source_locations {
   };
 
   void f() {
     A<float, float> &af = E(); // expected-error{{no viable conversion}}
     A<float, int> &af2 = E();
     const A<float, int> &caf2 = E();
   }
 
-  // Check 
+  // Check
   template<typename T>
   struct E2 {
     operator T
     * // expected-error{{pointer to a reference}}
     () const;
   };
 
   E2<int&> e2i; // expected-note{{in instantiation}}

 #else
     // expected-error-re@-4 {{cannot specify any part of a return type in the declaration of a conversion function; use an alias template to declare a conversion to 'T (&)()'{{$}}}}
 #endif
 
   };
 }
 
 namespace smart_ptr {
-  class Y { 
+  class Y {
     class YRef { };
 
     Y(Y&);
 
   public:
     Y();
     Y(YRef);
 
#endif
   }
 }
 
 struct Any {
   Any(...);
 };
 
 struct Other {
-  Other(const Other &); 
+  Other(const Other &);
   Other();
 };
 
 void test_any() {
   Any any = Other();
 #if __cplusplus <= 199711L
   // expected-error@-2 {{cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtime}}
 #else
namespace PR7055 {
 
   auto_ptr foo();
 
   X e(foo());
 
   struct Y {
     Y(X);
   };
-  
   Y f2(foo());
 }
 
 namespace PR7934 {
   typedef unsigned char uint8;
 
   struct MutablePtr {
     MutablePtr() : ptr(0) {}
namespace rdar8018274 {
   struct Base {
     operator int();
   };
 
   struct Derived1 : Base { };
 
   struct Derived2 : Base { };
 
-  struct SuperDerived : Derived1, Derived2 { 
+  struct SuperDerived : Derived1, Derived2 {
     using Derived1::operator int;
   };
 
   struct UeberDerived : SuperDerived {
     operator long();
   };
 
   void test2(UeberDerived ud) {
     int i = ud; // expected-error{{ambiguous conversion from derived class 'rdar8018274::UeberDerived' to base class 'rdar8018274::Base'}}
   }
 
   struct Base2 {
     operator int();
   };
 
   struct Base3 {
     operator int();
   };
 
-  struct Derived23 : Base2, Base3 { 
+  struct Derived23 : Base2, Base3 {
     using Base2::operator int;
   };
 
   struct ExtraDerived23 : Derived23 { };
 
   void test3(ExtraDerived23 ed) {
     int i = ed;
   }

 }
 
 namespace PR9336 {
   template<class T>
   struct generic_list
   {
     template<class Container>
     operator Container()
-    { 
+    {
       Container ar;
       T* i;
       ar[0]=*i;
       return ar;
     }
   };
 
   template<class T>

clang/test/SemaCXX/coroutine-rvo.cpp

-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -stdlib=libc++ -std=c++1z -fcoroutines-ts -fsyntax-only
+// RUN: %clang_cc1 -verify -std=c++17 -fcoroutines-ts -fsyntax-only %s
 
 namespace std::experimental {
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 
 template <> struct coroutine_handle<void> {

 }
 
 struct suspend_never {
   bool await_ready() noexcept;
   void await_suspend(std::experimental::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct MoveOnly {
-  MoveOnly() {};
+  MoveOnly() = default;
   MoveOnly(const MoveOnly&) = delete;
-  MoveOnly(MoveOnly&&) noexcept {};
-  ~MoveOnly() {};
+  MoveOnly(MoveOnly &&) = default;
+};
+
+struct NoCopyNoMove {
+  NoCopyNoMove() = default;
+  NoCopyNoMove(const NoCopyNoMove &) = delete; // expected-note 4{{'NoCopyNoMove' has been explicitly marked deleted here}}
 };
 
 template <typename T>
 struct task {
   struct promise_type {
     auto initial_suspend() { return suspend_never{}; }
     auto final_suspend() noexcept { return suspend_never{}; }
     auto get_return_object() { return task{}; }
     static void unhandled_exception() {}
-    void return_value(T&& value) {}
+    void return_value(T &&value) {} // expected-note 4{{passing argument}}
   };
 };
 
-task<MoveOnly> f() {
-  MoveOnly value;
+task<NoCopyNoMove> local2val() {
+  NoCopyNoMove value;
+  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
+  // expected-error@-1 {{value reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
+}
+
+task<NoCopyNoMove &> local2ref() {
+  NoCopyNoMove value;
+  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
+}
+
+// We need the move constructor for construction of the coroutine.
+task<MoveOnly> param2val(MoveOnly value) {
   co_return value;
 }
 
-int main() {
-  f();
-  return 0;
+task<NoCopyNoMove> lvalue2val(NoCopyNoMove &value) {
+  co_return value; // expected-error {{rvalue reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
+}
+
+task<NoCopyNoMove> rvalue2val(NoCopyNoMove &&value) {
+  co_return value; // expected-error {{rvalue reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
+  // expected-error@-1 {{call to deleted constructor of 'NoCopyNoMove'}}
+}
+
+task<NoCopyNoMove &> lvalue2ref(NoCopyNoMove &value) {
+  co_return value;
+}
+
+task<NoCopyNoMove &> rvalue2ref(NoCopyNoMove &&value) {
+  co_return value; // expected-error {{call to deleted constructor of 'NoCopyNoMove'}}
+}
+
+struct To {
+  operator MoveOnly() &&;
+};
+task<MoveOnly> conversion_operator() {
+  To t;
+  co_return t;
+}
+
+struct Construct {
+  Construct(MoveOnly);
+};
+task<Construct> converting_constructor() {
+  MoveOnly w;
+  co_return w;
+}
+
+struct Derived : MoveOnly {};
+task<MoveOnly> derived2base() {
+  Derived result;
+  co_return result;
 }
 
-// expected-no-diagnostics
+struct RetThis {
+  task<RetThis> foo() && {
+    co_return *this; // expected-error {{rvalue reference to type 'RetThis' cannot bind to lvalue of type 'RetThis'}}
+  }
+};
+
+template <typename, typename>
+struct is_same { static constexpr bool value = false; };
+
+template <typename T>
+struct is_same<T, T> { static constexpr bool value = true; };
+
+template <typename T>
+struct template_return_task {
+  struct promise_type {
+    auto initial_suspend() { return suspend_never{}; }
+    auto final_suspend() noexcept { return suspend_never{}; }
+    auto get_return_object() { return template_return_task{}; }
+    static void unhandled_exception();
+    template <typename U>
+    void return_value(U &&value) {
+      static_assert(is_same<T, U>::value);
+    }
+  };
+};
+
+template_return_task<MoveOnly> param2template(MoveOnly value) {
+  co_return value; // We should deduce U = MoveOnly.
+}
+
+template_return_task<NoCopyNoMove &> lvalue2template(NoCopyNoMove &value) {
+  co_return value; // We should deduce U = NoCopyNoMove&.
+}

clang/test/SemaCXX/coroutines.cpp

 // This file contains references to sections of the Coroutines TS, which can be
 // found at http://wg21.link/coroutines.
 
-// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify=expected          %s -fcxx-exceptions -fexceptions -Wunused-result
 
 void no_coroutine_traits_bad_arg_await() {
   co_await a; // expected-error {{include <experimental/coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 void no_coroutine_traits_bad_arg_yield() {
   co_yield a; // expected-error {{include <experimental/coroutine>}}
struct await_ready_explicit_bool {
   void await_resume();
 };
 template <class SuspendTy>
 struct await_suspend_type_test {
   bool await_ready();
   // expected-error@+2 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &')}}
   // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &&')}}
   SuspendTy await_suspend(std::experimental::coroutine_handle<>);
+  // cxx20_2b-warning@-1 {{volatile-qualified return type 'const volatile bool' is deprecated}}
   void await_resume();
 };
 void test_bad_suspend() {
   {
     // FIXME: The actual error emitted here is terrible, and no number of notes can save it.
     bad_await_ready_return a;
     // expected-error@+1 {{value of type 'void' is not contextually convertible to 'bool'}}
     co_await a; // expected-note {{call to 'await_ready' implicitly required by coroutine function here}}
   }
   {
     bad_await_suspend_return b;
     co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
   }
   {
     await_ready_explicit_bool c;
     co_await c; // OK
   }
   {
     await_suspend_type_test<bool &&> a;
     await_suspend_type_test<bool &> b;
     await_suspend_type_test<const void> c;
-    await_suspend_type_test<const volatile bool> d;
+    await_suspend_type_test<const volatile bool> d; // cxx20_2b-note {{in instantiation of template class}}
     co_await a; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
     co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
     co_await c; // OK
     co_await d; // OK
   }
 }
 
 template <int ID = 0>
struct TestType {
   CoroMemberTag test_sanity(int *) const {
     auto TC = co_yield 0;
     static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
     static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
     static_assert(TC.MatchesArgs<const TestType &, int *>, "");
   }
 
   CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
+    // cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void *volatile' is deprecated}}
     auto TC = co_yield 0;
     static_assert(TC.MatchesArgs<const TestType &, int *, const float &&, volatile void *volatile>, "");
   }
 
   CoroMemberTag test_qual() const volatile {
     auto TC = co_yield 0;
     static_assert(TC.MatchesArgs<const volatile TestType &>, "");
   }
struct DepTestType {
   CoroMemberTag test_qual() {
     auto TC = co_yield 0;
     static_assert(TC.template MatchesArgs<DepTestType &>, "");
     static_assert(!TC.template MatchesArgs<DepTestType>, "");
     static_assert(!TC.template MatchesArgs<DepTestType *>, "");
   }
 
   CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
+    // cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void *volatile' is deprecated}}
     auto TC = co_yield 0;
     static_assert(TC.template MatchesArgs<const DepTestType &, int *, const float &&, volatile void *volatile>, "");
   }
 
   CoroMemberTag test_qual() const volatile {
     auto TC = co_yield 0;
     static_assert(TC.template MatchesArgs<const volatile DepTestType &>, "");
   }

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

-// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
-// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14    %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 
 auto f(); // expected-note {{previous}}
 int f(); // expected-error {{differ only in their return type}}
 
 auto &g();
 auto g() -> auto &;
 
 auto h() -> auto *;
namespace Constexpr {
   constexpr auto f1(int n) { return n; }
   template<typename T> struct X { constexpr auto f() {} }; // PR18746
   template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}
   void f() {
     X<int>().f();
     Y<void>().f();
     constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}}
   }
-  struct NonLiteral { ~NonLiteral(); } nl; // expected-note {{user-provided destructor}}
+  struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}}
+  // cxx20_2b-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}}
   constexpr auto f2(int n) { return nl; } // expected-error {{return type 'Constexpr::NonLiteral' is not a literal type}}
 }
 
 // It's not really clear whether these are valid, but this matches g++.
 using size_t = decltype(sizeof(0));
 auto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}}
 auto operator delete(void *, const char*); // expected-error {{must return type 'void'}}
 

 namespace MemberTemplatesWithDeduction {
   struct M {
     template<class T> auto foo(T t) { return t; }
     template<class T> auto operator()(T t) const { return t; }
     template<class T> static __attribute__((unused)) int static_foo(T) {
       return 5;
     }
     template<class T> operator T() { return T{}; }
-    operator auto() { return &static_foo<int>; } 
+    operator auto() { return &static_foo<int>; }
   };
   struct N : M {
     using M::foo;
     using M::operator();
     using M::static_foo;
     using M::operator auto;
   };
-  
   template <class T> int test() {
     int i = T{}.foo(3);
     T m = T{}.foo(M{});
     int j = T{}(3);
     M m2 = M{}(M{});
     int k = T{}.static_foo(4);
     int l = T::static_foo(5);
     int l2 = T{};
     struct X { };
     X x = T{};
     return 0;
   }
   int Minst = test<M>();
   int Ninst = test<N>();
-  
 }
 }
 
 // We resolve a wording bug here: 'decltype(auto)' should not be modeled as a
 // decltype-specifier, just as a simple-type-specifier. All the extra places
 // where a decltype-specifier can appear make no sense for 'decltype(auto)'.
 namespace DecltypeAutoShouldNotBeADecltypeSpecifier {
   namespace NNS {
namespace CurrentInstantiation {
   int k1 = S<int>().g();
   int k2 = S<int>().h(false);
 
   template<typename T> struct U {
  #ifndef DELAYED_TEMPLATE_PARSING
     auto f(); // expected-note {{here}}
     int g() { return f(); } // expected-error {{cannot be used before it is defined}}
  #else
-    auto f(); 
-    int g() { return f(); } 
+    auto f();
+    int g() { return f(); }
  #endif
   };
- #ifndef DELAYED_TEMPLATE_PARSING 
+ #ifndef DELAYED_TEMPLATE_PARSING
   template int U<int>::g(); // expected-note {{in instantiation of}}
  #else
   template int U<int>::g();
  #endif
   template<typename T> auto U<T>::f() { return T(); }
   template int U<short>::g(); // ok
 }
 
namespace PR33222 {
   template<> auto *B<char[1]>::q() { return (int*)0; }
   template<> auto B<char[2]>::q() { return (int*)0; } // expected-error {{return type}}
   template<> int B<char[3]>::q() { return 0; } // expected-error {{return type}}
 }
 
 namespace PR46637 {
   using A = auto () -> auto; // expected-error {{'auto' not allowed in type alias}}
   using B = auto (*)() -> auto; // expected-error {{'auto' not allowed in type alias}}
-  template<auto (*)() -> auto> struct X {}; // expected-error {{'auto' not allowed in template parameter until C++17}}
+  template<auto (*)() -> auto> struct X {}; // cxx14-error {{'auto' not allowed in template parameter until C++17}}
   template<typename T> struct Y { T x; };
   Y<auto() -> auto> y; // expected-error {{'auto' not allowed in template argument}}
 }

clang/test/SemaCXX/return-stack-addr.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected       %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected       %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11 %s
 
 int* ret_local() {
   int x = 1;
   return &x; // expected-warning {{address of stack memory}}
 }
 
 int* ret_local_array() {
   int x[10];
(void) [] {
     };
   };
   (void) [] {
     int a;
     return [a] {};
   };
   (void) [] {
     int a;
-    // expected-warning@+1 {{C++14}}
+    // cxx11-warning@+1 {{C++14}}
     return [&b = a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured by reference via initialization of lambda capture 'b'}}
   };
   (void) [] {
     int a;
-    // expected-warning@+1 {{C++14}}
+    // cxx11-warning@+1 {{C++14}}
     return [b = &a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured via initialization of lambda capture 'b'}}
   };
 }
 
 struct HoldsPointer { int *p; };
 
 HoldsPointer ret_via_member_1() {
   int n;
   return {&n}; // expected-warning {{address of stack memory associated with local variable 'n' returned}}
 }
 HoldsPointer ret_via_member_2() {
   int n;
-  return HoldsPointer(HoldsPointer{&n}); // expected-warning {{address of stack memory associated with local variable 'n' returned}}
+  return HoldsPointer(HoldsPointer{&n}); // cxx11-warning {{address of stack memory associated with local variable 'n' returned}}
 }
 // FIXME: We could diagnose this too.
 HoldsPointer ret_via_member_3() {
   int n;
   const HoldsPointer hp = HoldsPointer{&n};
   return hp;
 }
 

clang/test/SemaCXX/warn-return-std-move.cpp

-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++20 -verify=cxx20 %s
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++17 -verify=expected %s
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++14 -verify=expected %s
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++11 -verify=expected %s
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++17 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++14 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -std=c++11 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=cxx20_2b -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20_2b -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
+
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
 
 // definitions for std::move
 namespace std {
 inline namespace foo {
 template <class T> struct remove_reference { typedef T type; };
 template <class T> struct remove_reference<T &> { typedef T type; };
 template <class T> struct remove_reference<T &&> { typedef T type; };
 

 
 Derived test1() {
     Derived d1;
     return d1;  // ok
 }
 Base test2() {
     Derived d2;
     return d2;  // e1
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d2)"
 }
 ConstructFromDerived test3() {
   Derived d3;
   return d3; // ok
 }
 ConstructFromBase test4() {
     Derived d4;
     return d4;  // e3
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d4)"
 }
 ConvertFromDerived test5() {
     Derived d5;
     return d5;  // e4
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d5)"
 }
 ConvertFromBase test6() {
     Derived d6;
     return d6;  // e5
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d6)"
 }
 
 // These test cases should not produce the warning.
 Derived ok1() { Derived d; return d; }
 Base ok2() { Derived d; return static_cast<Derived&&>(d); }
 ConstructFromDerived ok3() { Derived d; return static_cast<Derived&&>(d); }
 ConstructFromBase ok4() { Derived d; return static_cast<Derived&&>(d); }

 ConstructFromTrivialBase ok_trivial4(TrivialDerived d) { return d; }
 ConvertFromTrivialDerived ok_trivial5(TrivialDerived d) { return d; }
 ConvertFromTrivialBase ok_trivial6(TrivialDerived d) { return d; }
 
 // If the target is a parameter, do apply the diagnostic.
 Derived testParam1(Derived d) { return d; }
 Base testParam2(Derived d) {
     return d;  // e6
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConstructFromDerived testParam3(Derived d) {
   return d; // ok
 }
 ConstructFromBase testParam4(Derived d) {
     return d;  // e8
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConvertFromDerived testParam5(Derived d) {
     return d;  // e9
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConvertFromBase testParam6(Derived d) {
     return d;  // e10
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 
 // If the target is an rvalue reference parameter, do apply the diagnostic.
 Derived testRParam1(Derived&& d) {
     return d;  // e11
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 Base testRParam2(Derived&& d) {
     return d;  // e12
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConstructFromDerived testRParam3(Derived&& d) {
     return d;  // e13
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConstructFromBase testRParam4(Derived&& d) {
     return d;  // e14
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConvertFromDerived testRParam5(Derived&& d) {
     return d;  // e15
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 ConvertFromBase testRParam6(Derived&& d) {
     return d;  // e16
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
 }
 
 // But if the return type is a reference type, then moving would be wrong.
 Derived& testRetRef1(Derived&& d) { return d; }
 Base& testRetRef2(Derived&& d) { return d; }
 #if __cplusplus >= 201402L
 auto&& testRetRef3(Derived&& d) { return d; }
 decltype(auto) testRetRef4(Derived&& d) { return (d); }
 #endif
 
 // As long as we're checking parentheses, make sure parentheses don't disable the warning.
 Base testParens1() {
     Derived d;
     return (d);  // e17
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:15}:"std::move(d)"
 }
 ConstructFromDerived testParens2() {
   Derived d;
   return (d); // ok
 }
 
 // If the target is a catch-handler parameter, do apply the diagnostic.
 void throw_derived();
 Derived testEParam1() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e19
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 Base testEParam2() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e20
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 ConstructFromDerived testEParam3() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e21
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 ConstructFromBase testEParam4() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e22
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 ConvertFromDerived testEParam5() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e23
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 ConvertFromBase testEParam6() {
     try { throw_derived(); } catch (Derived d) { return d; }  // e24
-    // expected-warning@-1{{will be copied despite being returned by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being returned by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
     __builtin_unreachable();
 }
 
 // If the exception variable is an lvalue reference, we cannot be sure
 // that we own it; it is extremely contrived, but possible, for this to
 // be a reference to an exception object that was thrown via
 // `std::rethrow_exception(xp)` in Thread A, and meanwhile somebody else

 
 TriviallyCopyable ok_copy1() { TriviallyCopyable c; return c; }
 OnlyCopyable ok_copy2() { OnlyCopyable c; return c; }
 TriviallyCopyable ok_copyparam1(TriviallyCopyable c) { return c; }
 OnlyCopyable ok_copyparam2(OnlyCopyable c) { return c; }
 
 void test_throw1(Derived&& d) {
     throw d;  // e25
-    // expected-warning@-1{{will be copied despite being thrown by name}}
-    // expected-note@-2{{to avoid copying}}
+    // cxx11_17-warning@-1{{will be copied despite being thrown by name}}
+    // cxx11_17-note@-2{{to avoid copying}}
     // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:12}:"std::move(d)"
 }
 
 void ok_throw1() {
   Derived d;
   throw d;
 }
 void ok_throw2(Derived d) { throw d; }
 void ok_throw3(Derived &d) { throw d; }
 void ok_throw4(Derived d) { throw std::move(d); }
 void ok_throw5(Derived &d) { throw std::move(d); }
 void ok_throw6(Derived &d) { throw static_cast<Derived &&>(d); }
 void ok_throw7(TriviallyCopyable d) { throw d; }
 void ok_throw8(OnlyCopyable d) { throw d; }
 
 namespace test_delete {
 struct Base {
   Base();
-  Base(Base &&) = delete; // cxx20-note {{'Base' has been explicitly marked deleted here}}
+  Base(Base &&) = delete; // cxx20_2b-note {{'Base' has been explicitly marked deleted here}}
   Base(Base const &);
 };
 
 struct Derived : public Base {};
 
 Base test_ok() {
   Derived d;
-  return d; // cxx20-error {{call to deleted constructor of 'test_delete::Base'}}
+  return d; // cxx20_2b-error {{call to deleted constructor of 'test_delete::Base'}}
 }
 } // namespace test_delete