[test] Make tests pass regardless of gnu++14/gnu++17 default

[MaskRay]

Summary

GCC from 11 onwards defaults to -std=gnu++17 for C++ source files. We want to do the same
(https://discourse.llvm.org/t/c-objc-switch-to-gnu-17-as-the-default-dialect/64360).
Add __cplusplus < 201703L, adjust -verify, or add -std=c++14 so that tests
will pass regardless of gnu++14/gnu++17 default.

We have a desire to mark a test compatible with multiple language standards.
There are ongoing discussions how to add markers in the long term:

• https://discourse.llvm.org/t/iterating-lit-run-lines/62596
• https://discourse.llvm.org/t/lit-run-a-run-line-multiple-times-with-different-replacements/64932

As a workaround in the short term, add lit substitutions %std_cxx98-,
%std_cxx11-14, etc. They can be used for tests which work across multiple
language standards. If a range has n standards, run lit multiple times, with
LIT_CLANG_STD_GROUP=0, LIT_CLANG_STD_GROUP=1, etc to cover all n standards.

[junaire]

I wonder what's the difference between this patch and https://reviews.llvm.org/D124434 ? Also add some reviewers that get involved in the previous discussion.

[aaron.ballman]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

2

I'm not really keen on this sort of change because it loses test coverage for other language standard versions. We usually try to write our tests to be standard version agnostic and only specify a specific language mode only when absolutely necessary, which doesn't seem to be the case for a lot of the tests in this patch (like this one).

clang/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp

3

This is another example where we lose all testing in the future when we go to change the default language standard version. It's fine to have a C++14-specific test, but we should still have a test which has no mode specified.

[MaskRay]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

2

I think we can identify such issues (tests which want to test the latest mature standard) and fix them post-transition. This way the transition patch feels more isolated and can more easily be reverted.

Not sure whether @junaire wants to work on this...

[aaron.ballman]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

2

I think we can identify such issues (tests which want to test the latest mature standard) and fix them post-transition. This way the transition patch feels more isolated and can more easily be reverted.

That feels backwards to me, but maybe I'm misunderstanding. If there are tests that are specifically testing C++14 behavior (that did not carry forward into C++17 or later) but don't have a language standard specified on the RUN line, I think we should fix those *before* transitioning the default language standard version because those are NFC fixes that improve the test clarity even if we never make the transition. The transition patch should remain isolated and easily revertible with that approach, but there's less risk that nobody goes back and fixes the tests post-transition.

[junaire]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

2

Not sure whether @junaire wants to work on this...

I don't think I have enough knowledge and experience to do this work, So I would like to abandon my previous patch to hope you can pick it up!

[MaskRay]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

2

I'll fix some tests.

[MaskRay]

fix some tests in a better way

[aaron.ballman]

I didn't do a full review because I spotted enough concerns that we might want to talk about the approach more first. I think the goal should be to avoid adding a -std= to any RUN line unless the test really requires it. I spotted a lot of instances where we went from testing the current language standard mode to losing testing for all language modes later than 14 or 17, which will give us problems when we go to update to C++20 or beyond. I think we want to use more #if __cplusplus or disable diagnostics when possible.

I made another lamentation about the lack of lit facilities that I think would solve these problems for us, but that's a big ask and is not something I insist upon for this. But if you felt like it was a good approach and wanted to work on it, I certainly wouldn't be sad about it. :-D

clang/lib/Basic/LangStandards.cpp

81

Unintended change used to find the tests that needed updating?

clang/test/AST/ast-dump-undeduced-expr.cpp

1

What from this test requires C++14?

clang/test/AST/sourceranges.cpp

1–2

I assume this change is because we're testing c++17 on the next RUN line and you want to be sure we still get the old test coverage?

The trouble is, when we bump from C++17 to C++20, we'll lose the test coverage for the latest standard.

(Not your problem per se, but I continue to think we have a lit deficiency where we need some facilities to say "run this test in C++N and later", "run this test in C89 through CN", or "run this test in all C++ language modes", etc.)

clang/test/Analysis/blocks.m

2

What from this test is invalid in C++17?

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

1

Why not pass -Wno-dynamic-exception-spec instead of limiting the test (we support dynamic exception specifications in newer language modes and it would be good to not lose that test coverage there).

clang/test/CXX/except/except.spec/p9-dynamic.cpp

1

Same question here as above

[MaskRay]

Add lit substitutions

[MaskRay]

It will take some time to fix all tests properly. Let's have a guideline how to fix them properly. I tried fixing some using several patterns in the last revision. I didn't fix all, because it would likely lead to an unsatisfactory result and I would spend more time :)

A construct which causes an error with C++17 onwards

I keep the existing RUN: lines and use something like

#if __cplusplus < 201703L
void* operator new[](std::size_t) throw(std::bad_alloc); 
#endif

it the construct appears tested elsewhere or

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

if the test file appears the proper place to test the construct.

Pre-C++17 and C++17 have different results

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.
Do all CodeGenCXX tests have to be fixed?

clang/test/AST/ast-dump-undeduced-expr.cpp

1

The C++17 diagnostics uses static inline constexpr while pre-C++17 uses static constexpr. Used a regex instead.

clang/test/AST/sourceranges.cpp

1–2

FileCheck does not ignore preprocessor skipped ranges, so it is very difficult to work with both C++14/C++17 defaults, if our intention is to not touch such tests in the default changing patch.

I think the best strategy is to do another pass to clean up the tests after the transition, not trying to address everything in this patch.

clang/test/Analysis/blocks.m

2

Added __attribute__((__nothrow__)) in C++17 mode.

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

1

TIL -Wno-dynamic-exception-spec. Adopted.

clang/test/CXX/except/except.spec/p9-dynamic.cpp

1

The check prefixes assume that this is for C++14.

[dblaikie]

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Yeah, that's the main/a major concern as @aaron.ballman has mentioned.

I think in this case a regex over either would be acceptable, since the test probably wasn't intending to test the particular wording for a particular version (presumably if this is the place where this separate wording is uniquely used (rather than some generic diagnostic infrastructure change) then it's got a C++17 test already)

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.

I think where #if works well, it seems good to prefer it, yeah.

Do all CodeGenCXX tests have to be fixed?

I think so.

clang/test/AST/sourceranges.cpp

1–2

I think the best strategy is to do another pass to clean up the tests after the transition, not trying to address everything in this patch.

Not everything needs to be addressed in this patch - these cleanups can be in several preliminary patches that are isolated and not dependent on the switch to C++17.

It looks like in this case there's one CHECK-1Z that's out of place (line 111, test seems to pass OK even if that's a plain CHECK so I guess it probably should be) - and the rest are all at the end, which could be moved to a separate file and done with a hardcoded C++17 target. (but yeah, after the default switch we might end up wanting to remove the hardcoded 17 (allowing the test to become "17 and above"), move more test coverage over to here and leave whatever's 14 specific in the old test)

(maybe as a separate pass, though, to your point - we might be able to go through and remove -std=c++17 from tests once that's the default, so the tests are forwards compatible to the next language version, most likely - but, again, a broader LIT feature that @aaron.ballman is referring to, where tests could specify which configurations (beyond language versions, this could also help cover things like... oh, right here: https://reviews.llvm.org/D125946, tests could be assumed to be correct for clang-repl too, and some mode where clang-repl's used instead of clang for broad-scale testing of clang-repl)

clang/test/CXX/except/except.spec/p9-dynamic.cpp

1

so in this case the 17 test could become language-agnostic after the version default change?

[aaron.ballman]

In D131464#3713705, @MaskRay wrote:

It will take some time to fix all tests properly. Let's have a guideline how to fix them properly. I tried fixing some using several patterns in the last revision. I didn't fix all, because it would likely lead to an unsatisfactory result and I would spend more time :)

A construct which causes an error with C++17 onwards

I keep the existing RUN: lines and use something like

#if __cplusplus < 201703L
void* operator new[](std::size_t) throw(std::bad_alloc); 
#endif

it the construct appears tested elsewhere or

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

if the test file appears the proper place to test the construct.

This makes sense to me for sema tests. For tests which cannot have errors in them, like codegen tests or analysis tests, I would say this is a case where we would exhaustively test the old language standards up to C++17 and not beyond (perhaps with a boilerplate comment about why no newer versions need to be tested).

Pre-C++17 and C++17 have different results

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Yeah, we want to avoid making the tests less relevant in the future when possible. The suggestion from @dblaikie to use a regex in this case makes a lot of sense to me in the situation where what's being tested is not specifically the divergence in diagnostic behavior. e.g., if the test is "do we give a sensible warning here?" then use a regex for this situation, but if the test is "do we give the correct form of the warning here?" then use -verify= and try to leave a RUN line without a specific language standard on it if possible.

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.

I wouldn't say "in all cases", but certainly in cases where it improves the readability of the test or ensures we don't lose test coverage. Cases with FileCheck are a problem, but hopefully aren't too prevalent in the Parser and Sema tests.

Do all CodeGenCXX tests have to be fixed?

Yes, but in that case I expect (at least for errors), it's more a matter of adding RUN lines for all the relevant modes we need to test (since codegen tests really should not be caring about warning diagnostic wording, though some tests still do).

clang/test/AST/sourceranges.cpp

1–2

Not everything needs to be addressed in this patch - these cleanups can be in several preliminary patches that are isolated and not dependent on the switch to C++17.

+1 -- I am imagining the way we want to go forward is to have several patches handling these cleanups. One can handle cases where we need to add a regex or a verify prefix, another which splits files into two as needed, another can introduce new lit features, another can start to use those features, and so on.

This way, the default changing patch can hopefully be relatively small and narrow in scope. Once it's landed, we probably will want to do even more cleanup like removing -std=c++17 RUN lines when possible, etc.

Ultimately, I think the lit feature improvements will require us to go through a lot/most/all-ish of the tests to fix up their RUN lines. When we made the switch to C++14, I don't think we went through and cleaned up tests that already specified -std=c++1y or -std=c++14, so I would not be surprised to see a bunch of tests that lost future version coverage from that switch as well. Whether we want to bite the bullet and do that work up front instead of looking at/touching a lot of tests twice is worth thinking about.

llvm/utils/lit/lit/llvm/config.py

570 ↗

(On Diff #451586)

If we like this approach, we should probably add add_stdc as well (not as part of this patch, we can do all of C++ first, then come back and hit up C after we've finished).

573 ↗

(On Diff #451586)

Maybe we can use clang_std_values[-1] so we don't have to hardcode this?

579 ↗

(On Diff #451586)

One thing we should consider is whether we want to run in *all* the specified language modes instead of just the newest mode. This will make running tests slower because we'll run significantly more of them, and it might get awkward if a lot of tests change behavior in the different language modes, so I don't suggest it as part of this patch.

[MaskRay]

Sorry, my previous main comment had been written before I introduced LIT_CLANG_STD_GROUP in llvm/utils/lit/lit/llvm/config.py. The multiple %clang_cc1 approach actually looks like the following.
Note the use of %stdcxx_17- to make the test future-proof.
(It is non-trivial to run one RUN line multiples times with different LIT_CLANG_STD_GROUP. For now I just test locally with different LIT_CLANG_STD_GROUP.)

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify %stdcxx_17- -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}} \
                                       // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}} \
                                       // precxx17-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

If this is changed to use #if __cplusplus >= 201703L, there will be multiple lines with relative line numbers (e.g. @-2 @-4)

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

Personally I prefer multiple %clang_cc1 over #if. The first few lines give users a first impression. The dispatch makes it clear the test has different behaviors with the %stdcxx_* described dialects.

llvm/utils/lit/lit/llvm/config.py

579 ↗

(On Diff #451586)

This is difficult in lit. Will answer in my main comment.

[aaron.ballman]

In D131464#3716905, @MaskRay wrote:

Sorry, my previous main comment had been written before I introduced LIT_CLANG_STD_GROUP in llvm/utils/lit/lit/llvm/config.py. The multiple %clang_cc1 approach actually looks like the following.
Note the use of %stdcxx_17- to make the test future-proof.
(It is non-trivial to run one RUN line multiples times with different LIT_CLANG_STD_GROUP. For now I just test locally with different LIT_CLANG_STD_GROUP.)

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify %stdcxx_17- -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}} \
                                       // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}} \
                                       // precxx17-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Personally, I like this style. I tend to be a heavy user of -verify prefixes though, so I might be biased.

If this is changed to use #if __cplusplus >= 201703L, there will be multiple lines with relative line numbers (e.g. @-2 @-4)

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

FWIW, you don't have to use relative markers, but that uses an even less common idiom of bookmarks. e.g.,

register int ro; // expected-error {{illegal storage class on file-scoped variable}} \
                    #bookmark
#if __cplusplus >= 201703L
// expected-error@#bookmark {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@#bookmark {{'register' storage class specifier is deprecated}}
#endif

Personally I prefer multiple %clang_cc1 over #if. The first few lines give users a first impression. The dispatch makes it clear the test has different behaviors with the %stdcxx_* described dialects.

I tend to have the same opinion.

[MaskRay]

fix tests

[aaron.ballman]

I like the direction this is going; I ran into some questions on the tests about whether we should use a range or not and other small things, but I think this is getting close.

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

2

Should this be C++17+?

clang/test/CodeGen/typedef_alignment_mismatch_warning.cpp

2

Same question here about C++17+?

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

Should we drop the %stdcxx_98- entirely from tests and not have any -std flag (e.g., no such flags tells lit to run the test in all language modes, eventually)?

clang/test/CodeGenCXX/override-bit-field-layout.cpp

2

17+?

clang/test/CodeGenCXX/override-layout.cpp

1–6

Pre 14? Post 17?

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

Is this test specific to C++14?

clang/test/Parser/cxx-casting.cpp

1–3

LG given that lit doesn't run multiple tests yet, so switching to a range would lose coverage.

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

1

Is this one only for C++14 or should there be a range used instead?

llvm/utils/lit/lit/llvm/config.py

573 ↗

(On Diff #451586)

Thoughts?

579 ↗

(On Diff #451586)

It's unfortunate that it's difficult in lit. I'm fine punting on that work for now, but I think we should try to invest in it (or are you saying "difficult" as in "not worth the effort"?)

[MaskRay]

address comments

[MaskRay]

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

The proposal is probably clean if we the majority of tests work with C++98, but I think we have accrued many tests which don't work with C++98 so we need directives like %stdcxx_11-.

Since C++98 is actually uncommon now. I prefer explicit %stdcxx_98- to indicate a test works with C++98.

clang/test/CodeGenCXX/override-layout.cpp

1–6

Unfortunately, C++17 and C++20 have different behaviors. I haven't investigated why it is the case.

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

This is similar to the previous -fdump-record-layouts test that the dump order is different across 14, 17, 20. I do now know whether there is something which should be improved to add the coverage.

For now I assume it is not this patch's responsibility to address it.

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

1

This is a hack for presumably older language dialects. Switched to a range.

[MaskRay]

llvm/utils/lit/lit/llvm/config.py

570 ↗

(On Diff #451586)

Agree. This can be left as another patch.

579 ↗

(On Diff #451586)

I have asked for help on https://discourse.llvm.org/t/lit-run-a-run-line-multiple-times-with-different-replacements/64932

[aaron.ballman]

This LGTM but I'd appreciate it if @dblaikie could also give it a once over so we have more than one sets of eyes on the changes in case I've missed something.

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

Since C++98 is actually uncommon now. I prefer explicit %stdcxx_98- to indicate a test works with C++98.

Heheh, there's still a *ton* of C++98 code out there, but I'm okay being explicit just the same (it makes the tests easier to read).

clang/test/CodeGenCXX/override-layout.cpp

1–6

Ah, that's fine to do in a follow-up then. Thanks!

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

Agreed, thanks for the explanation!

[MaskRay]

Fix a test

clang/lib/Basic/LangStandards.cpp

LangStandard::Kind clang::getDefaultLanguageStandard(clang::Language Lang,
   case Language::CXX:
   case Language::ObjCXX:
     if (CLANG_DEFAULT_STD_CXX != LangStandard::lang_unspecified)
       return CLANG_DEFAULT_STD_CXX;
 
     if (T.isDriverKit())
       return LangStandard::lang_gnucxx17;
     else
-      return LangStandard::lang_gnucxx14;
+      return LangStandard::lang_gnucxx17;
   case Language::RenderScript:
     return LangStandard::lang_c99;
   case Language::HIP:
     return LangStandard::lang_hip;
   case Language::HLSL:
     return LangStandard::lang_hlsl2021;
   }
   llvm_unreachable("unhandled Language kind!");
 }

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=c_mode   -ast-dump %s       | FileCheck %s --check-prefix=C
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=cxx_mode -ast-dump %s -x c++| FileCheck %s --check-prefix=CXX
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=cxx_mode -ast-dump %s -x c++ -std=c++14 | FileCheck %s --check-prefix=CXX
 
 // c_mode-no-diagnostics
 
 #ifdef __cplusplus
 #define CONST constexpr
 #else
 #define CONST __attribute__((const))
 #endif

clang/test/AST/ast-dump-openmp-begin-declare-variant_template_3.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s -x c++| FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s -std=c++14| FileCheck %s
 // expected-no-diagnostics
 // PR47655
 
 template <typename T> struct S {
   S(int, T *) {}
 };
 
 template <typename T>

clang/test/AST/ast-dump-undeduced-expr.cpp

-// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -ast-dump %s | FileCheck %s
+// RUN: not %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -ast-dump %s | FileCheck %s
 
 struct Foo {
   static constexpr auto Bar = ;
 };
 
 // CHECK: -VarDecl {{.*}} invalid Bar 'const auto' static constexpr

clang/test/AST/sourceranges.cpp

-// RUN: %clang_cc1 -triple i686-mingw32 -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -triple i686-mingw32 -ast-dump %s | FileCheck %s
 // RUN: %clang_cc1 -triple i686-mingw32 -std=c++1z -ast-dump %s | FileCheck %s -check-prefix=CHECK-1Z
 
 template<class T>
 class P {
  public:
   P(T* t) {}
 };
 
 namespace foo {

clang/test/Analysis/blocks.m

 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -verify -Wno-strict-prototypes %s
-// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -verify -x objective-c++ %s
+// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -verify -x objective-c++ -std=c++14 %s
 
 //===----------------------------------------------------------------------===//
 // The following code is reduced using delta-debugging from Mac OS X headers:
 //===----------------------------------------------------------------------===//
 
 typedef __builtin_va_list va_list;
 typedef unsigned int uint32_t;
 typedef struct dispatch_queue_s *dispatch_queue_t;

clang/test/Analysis/exploded-graph-rewriter/objects_under_construction.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
-// RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
+// RUN: %clang_cc1 -std=c++14 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyze-function "test()" \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
 
 struct S {
   S() {}
 };

clang/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp

 // RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++11 %s
 // RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
 int *use_new(int N) {
   if (N == 1)
     return new int;
   
   return new int [N];
 }
 
 void use_delete(int* ip, int N) {
   if (N == 1)
     delete ip;
   else
     delete [] ip;
 }
 
 namespace std {
   class bad_alloc { };
   
   typedef __SIZE_TYPE__ size_t;
 }
 
+#if __cplusplus < 201703L
 void* operator new(std::size_t) throw(std::bad_alloc);
 #if __cplusplus < 201103L
 // expected-note@-2 {{previous declaration}}
 #endif
+#endif
+
+#if __cplusplus < 201703L
 void* operator new[](std::size_t) throw(std::bad_alloc); 
+#endif
 void operator delete(void*) throw(); // expected-note{{previous declaration}}
 void operator delete[](void*) throw();
 
 void* operator new(std::size_t);
 #if __cplusplus < 201103L
 // expected-warning@-2 {{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
 #endif
 void operator delete(void*);
 #if __cplusplus < 201103L
 // expected-warning@-2 {{'operator delete' is missing exception specification 'throw()'}}
 #else
 // expected-warning@-4 {{previously declared with an explicit exception specification redeclared with an implicit}}
 #endif

clang/test/CXX/class.access/class.friend/p1.cpp

 namespace test6 {
   struct A {};
 
   struct B {
     friend
 #if __cplusplus >= 201103L
       constexpr
 #endif
-      A::A();
+      A::A()
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
     friend A::~A();
     friend
 #if __cplusplus >= 201402L
       constexpr
 #endif
-      A &A::operator=(const A&);
+      A &A::operator=(const A&)
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
   };
 }
 
 namespace test7 {
   template <class T> struct X {
     X();
     ~X();
     void foo();
     void bar();
   };
 
   class A {
     friend void X<int>::foo();
     friend X<int>::X();
     friend
 #if __cplusplus >= 201103L
       constexpr
 #endif
-      X<int>::X(const X&);
+      X<int>::X(const X&)
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
 
   private:
     A(); // expected-note 2 {{declared private here}}
   };
 
   template<> void X<int>::foo() {
     A a;
   }

clang/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp

 #endif
 
 auto void af(); // expected-error {{illegal storage class on function}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
 register int ro; // expected-error {{illegal storage class on file-scoped variable}}
-#if __cplusplus >= 201103L // C++11 or later
-// expected-warning@-2 {{'register' storage class specifier is deprecated}}
+#if __cplusplus >= 201703L
+// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-4 {{'register' storage class specifier is deprecated}}
 #endif
 
 register void rf(); // expected-error {{illegal storage class on function}}
 
 struct S {
   auto int ao; // expected-error {{storage class specified for a member declaration}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
   auto void af(); // expected-error {{storage class specified for a member declaration}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
   register int ro; // expected-error {{storage class specified for a member declaration}}
   register void rf(); // expected-error {{storage class specified for a member declaration}}
 };
 
 void foo(auto int ap, register int rp) {
-#if __cplusplus >= 201103L // C++11 or later
+#if __cplusplus >= 201703L
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
-// expected-warning@-3 {{'register' storage class specifier is deprecated}}
+// expected-error@-3 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-5 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
+// expected-warning@-6 {{'register' storage class specifier is deprecated}}
 #endif
   auto int abo;
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
   auto void abf(); // expected-error {{illegal storage class on function}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
   register int rbo;
-#if __cplusplus >= 201103L // C++11 or later
-// expected-warning@-2 {{'register' storage class specifier is deprecated}}
+#if __cplusplus >= 201703L
+// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-4 {{'register' storage class specifier is deprecated}}
 #endif
 
   register void rbf(); // expected-error {{illegal storage class on function}}
 }

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fsyntax-only -verify -std=c++14 %s
 
 // Dynamic specifications: valid types.
 
 struct Incomplete; // expected-note 3 {{forward declaration}}
 
 // Exception spec must not have incomplete types, or pointers to them, except
 // void.
 void ic1() throw(void); // expected-error {{incomplete type 'void' is not allowed in exception specification}}

clang/test/CXX/except/except.spec/p9-dynamic.cpp

-// RUN: %clang_cc1 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-PRE17
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-PRE17
 // RUN: %clang_cc1 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -std=c++17 -Wno-dynamic-exception-spec -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-17
 
 void external();
 
 // CHECK-LABEL: _Z6targetv(
 // CHECK: invoke void @_Z8externalv()
 // CHECK:      landingpad { i8*, i32 }
 // CHECK-NEXT:   filter [1 x i8*] [i8* bitcast (i8** @_ZTIi to i8*)]

clang/test/CXX/stmt.stmt/stmt.select/p3.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -std=c++1z -Wc++14-compat -verify %s -DCPP17
 
 int f();
 
 void g() {
   if (int x = f()) { // expected-note 2{{previous definition}}
     int x; // expected-error{{redefinition of 'x'}}
   } else {

clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s
 // RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++14 %s
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -triple=x86_64-linux-gnu %s -DCPP11ONLY
 
 // C++11 [temp.arg.nontype]p1:
 //
 //   A template-argument for a non-type, non-template template-parameter shall
 //   be one of:
 //   -- an integral constant expression; or
 //   -- the name of a non-type template-parameter ; or

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

-// RUN: %clang_cc1 -verify %s
+// RUN: %clang_cc1 -verify=expected,precxx17 -std=c++14 %s
+// RUN: %clang_cc1 -verify=expected,cxx17 -std=c++17 %s
 
 template <class T> struct Base {
   // expected-note@-1 2{{member type 'Base<int>' found by ambiguous name lookup}}
   // expected-note@-2 2{{member type 'Base<char>' found by ambiguous name lookup}}
   static void f();
 };
 
 struct X0 { };

 };
 
 namespace PR6717 {
   template <typename T>
   class WebVector {
   } // expected-error {{expected ';' after class}}
 
     WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \
-                                                expected-error{{a type specifier is required}}
+                                                precxx17-error{{a type specifier is required}} \
+                                                cxx17-error{{deduction guide declaration without trailing return type}} \
+                                                cxx17-error{{deduction guide cannot have a function definition}}
 
   template <typename C>
   WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}}
 }

clang/test/CodeGen/typedef_alignment_mismatch_warning.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -verify -fdata-sections -fcolor-diagnostics
+// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
+// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics
 
 // Warn for any function that
 //   * takes a pointer or a reference to an object (including "this" pointer),
 //   * that was defined for aligned object,
 //   * but is called with a pointer or reference to a less aligned object.
 // Attributes on using declarations are ignored.
 
 typedef __attribute__((aligned(2))) int Aligned2Int;
void test8() {
   auto SA8c = SA8a + SA8b;
   auto SA8d = SA8a - &SA8b;
   ++SA8c;
   --SA8d;
   TypedefAligned4 TA8a(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8b(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                        // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
-                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8d = TA8a - &TA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator-' may result in an unaligned pointer access}}
                                        // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator-' may result in an unaligned pointer access}}
-                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   ++TA8d;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator++' may result in an unaligned pointer access}}
   --TA8c;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator--' may result in an unaligned pointer access}}
   UsingAligned4 UA8a(11);
   UsingAligned4 UA8b(11);
   auto UA8c = UA8a + UA8b;
   auto UA8d = UA8a - &UA8b;
   ++UA8c;
   --UA8d;

clang/test/CodeGenCXX/align-avx-complete-objects.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -x c++ %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers -std=c++14 %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s
 // rdar://16254558
 
 typedef float AVX2Float __attribute__((__vector_size__(32)));
 
 
 volatile float TestAlign(void)
 {
        volatile AVX2Float *p = new AVX2Float;

clang/test/CodeGenCXX/copy-constructor-elim-2.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -no-enable-noundef-analysis -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s
 
 struct A { int x; A(int); ~A(); };
 A f() { return A(0); }
 // CHECK-LABEL: define{{.*}} void @_Z1fv
 // CHECK: call {{.*}} @_ZN1AC1Ei
 // CHECK-NEXT: ret void
 
 // Verify that we do not elide copies when constructing a base class.

clang/test/CodeGenCXX/debug-info-template-parameter.cpp

 // Test for DebugInfo for Defaulted parameters for C++ templates
 // Supported: -O0, standalone DI
 
-// RUN: %clang_cc1 -dwarf-version=5  -emit-llvm -triple x86_64-linux-gnu %s -o - \
+// RUN: %clang_cc1 -std=c++14 -dwarf-version=5  -emit-llvm -triple x86_64-linux-gnu %s -o - \
 // RUN:   -O0 -disable-llvm-passes \
 // RUN:   -debug-info-kind=standalone \
 // RUN: | FileCheck %s
 
 // CHECK: DILocalVariable(name: "f1", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F1_TYPE:[0-9]+]]
 // CHECK: [[F1_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]]}
 // CHECK: [[FIRST]] = !DITemplateTypeParameter(name: "T", type: !{{[0-9]*}})

clang/test/CodeGenCXX/debug-info-template-partial-specialization.cpp

-// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone | FileCheck %s
 namespace __pointer_type_imp
 {
   template <class _Tp, class _Dp, bool > struct __pointer_type1 {};
 
   // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "__pointer_type1<C, default_delete<C>, false>",
   // CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]]
   // CHECK-SAME:             identifier: "_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"
   template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false>

clang/test/CodeGenCXX/exception-spec-decay.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions %s -triple=i686-unknown-linux -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fexceptions %s -triple=i686-unknown-linux -emit-llvm -o - | FileCheck %s
 typedef int Array[10];
 
 void foo() throw (Array) {
   throw 0;
   // CHECK: landingpad
   // CHECK-NEXT: filter {{.*}} @_ZTIPi
 }
 

clang/test/CodeGenCXX/exceptions-cxx-ehsc.cpp

-// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -fexceptions -fcxx-exceptions -fexternc-nounwind | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -emit-llvm %s -o - -triple=i386-pc-win32 -fexceptions -fcxx-exceptions -fexternc-nounwind | FileCheck %s
 
 namespace test1 {
 struct Cleanup { ~Cleanup(); };
 extern "C" void never_throws();
 void may_throw();
 
 void caller() {
   Cleanup x;

clang/test/CodeGenCXX/exceptions-no-rtti.cpp

-// RUN: %clang_cc1 -fno-rtti -fcxx-exceptions -fexceptions %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -fno-rtti -fcxx-exceptions -fexceptions %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
 // CHECK: @_ZTIN5test11AE = linkonce_odr constant
 // CHECK: @_ZTIN5test11BE = linkonce_odr constant
 // CHECK: @_ZTIN5test11CE = linkonce_odr constant
 // CHECK: @_ZTIN5test11DE = linkonce_odr constant
 // CHECK: @_ZTIPN5test11DE = linkonce_odr constant {{.*}} @_ZTIN5test11DE
 
 // PR6974: this shouldn't crash

clang/test/CodeGenCXX/global-init.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - |FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck -check-prefix CHECK-NOEXC %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -mframe-pointer=non-leaf %s -o - \
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - |FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck -check-prefix CHECK-NOEXC %s
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -mframe-pointer=non-leaf %s -o - \
 // RUN:   | FileCheck -check-prefix CHECK-FP %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - -fno-builtin \
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - -fno-builtin \
 // RUN:   | FileCheck -check-prefix CHECK-NOBUILTIN %s
 
 struct A {
   A();
   ~A();
 };
 
 struct B { B(); ~B(); };

clang/test/CodeGenCXX/no-exceptions.cpp

-// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
 void g();
 
 // CHECK: define{{.*}} void @_Z1fv() [[NUW:#[0-9]+]]
 void f() throw (int) { 
 
   // CHECK-NOT: invoke void @_Z1gv
   g();
   // CHECK: call void @_Z1gv()
   // CHECK: ret void
 }
 
 // CHECK: attributes [[NUW]] = { mustprogress noinline nounwind{{.*}} }

clang/test/CodeGenCXX/override-bit-field-layout.cpp

-// RUN: %clang_cc1 -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s
 
 // CHECK: Type: struct S1
 // CHECK:   FieldOffsets: [0, 11]
 struct S1 {
   short a : 3;
   short b : 5;
 };
 
 // CHECK: Type: struct S2

clang/test/CodeGenCXX/override-layout.cpp

-// RUN: %clang_cc1 -w -fdump-record-layouts-simple %s > %t.layouts
-// RUN: %clang_cc1 -w -fdump-record-layouts-simple %s > %t.before
-// RUN: %clang_cc1 -w -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after
+// RUN: %clang_cc1 -std=c++14 -w -fdump-record-layouts-simple %s > %t.layouts
+// RUN: %clang_cc1 -std=c++14 -w -fdump-record-layouts-simple %s > %t.before
+// RUN: %clang_cc1 -std=c++14 -w -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after
 // RUN: diff -u %t.before %t.after
 // RUN: FileCheck %s < %t.after
 
 // If not explicitly disabled, set PACKED to the packed attribute.
 #ifndef PACKED
 #  define PACKED __attribute__((packed))
 #endif
 
 struct Empty1 { };
 struct Empty2 { };
 

clang/test/CodeGenCXX/reference-temporary-ms.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s
 
 const int __declspec(dllexport) &Exported = 42;
 
 // The reference temporary shouldn't be dllexport, even if the reference is.
 // CHECK: @"?$RT1@Exported@@3ABHB" = internal constant i32 42
 
 // CHECK: @"?Exported@@3ABHB" = dso_local dllexport constant i32* @"?$RT1@Exported@@3ABHB"

clang/test/CodeGenCXX/rtti-linkage.cpp

-// RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH
-// RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH %s
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH %s
 
 #include <typeinfo>
 
 // CHECK-BOTH: _ZTSP1C = internal constant
 // CHECK-BOTH: _ZTS1C = internal constant
 // CHECK-BOTH: _ZTI1C = internal constant
 // CHECK-BOTH: _ZTIP1C = internal constant
 // CHECK-BOTH: _ZTSPP1C = internal constant

clang/test/Layout/ms-x86-vtordisp.cpp

-// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
+// RUN: %clang_cc1 -std=c++14 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
+// RUN: %clang_cc1 -std=c++14 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 {
   int a;
   B0() : a(0xf00000B0) {}
   virtual void f() { printf("B0"); }

clang/test/Modules/update-exception-spec.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++14 -fexceptions -fcxx-exceptions -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s
 #include "a.h"
 void use(B *p);
 #include "c.h"
 void use(B *p) { g(p); }

clang/test/OpenMP/declare_mapper_messages.cpp

-// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s
+// RUN: %clang_cc1 -std=c++14 -verify -fopenmp -ferror-limit 100 %s
 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++98 %s
 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++11 %s
 
-// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s
+// RUN: %clang_cc1 -std=c++14 -verify -fopenmp-simd -ferror-limit 100 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 -std=c++98 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 -std=c++11 %s
 
 int temp; // expected-note {{'temp' declared here}}
 
 class vec {
 private:
   int p;                                                                // expected-note {{declared private here}}

clang/test/PCH/cxx-functions.cpp

 // Test this without pch.
-// RUN: %clang_cc1 -include %S/cxx-functions.h -fsyntax-only -verify %s
+// RUN: %clang_cc1 -include %S/cxx-functions.h -fsyntax-only -verify -std=c++14 %s
 
-// RUN: %clang_cc1 -x c++-header -emit-pch -o %t %S/cxx-functions.h
-// RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify %s
+// RUN: %clang_cc1 -x c++-header -std=c++14 -emit-pch -o %t %S/cxx-functions.h
+// RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify -std=c++14 %s
 
 // expected-no-diagnostics
 
 
 void test_foo() {
   foo();
 }

clang/test/Parser/cxx-casting.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 char *const_cast_test(const char *var)
 {
   return const_cast<char*>(var);
 }
 
 struct A {
   virtual ~A() {}

clang/test/Parser/cxx-class.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++11 %s
 
 class C;
 class C {
 public:
 protected:
   typedef int A,B;

clang/test/Parser/cxx-template-argument.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -verify %s -fdelayed-template-parsing
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s -fdelayed-template-parsing
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -fdelayed-template-parsing
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -fdelayed-template-parsing
 
 template<typename T> struct A {};
 
 // Check for template argument lists followed by junk
 // FIXME: The diagnostics here aren't great...
 A<int+> int x; // expected-error {{expected '>'}} expected-note {{to match this '<'}} expected-error {{expected unqualified-id}}

clang/test/Parser/cxx-template-decl.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s
-// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 -std=gnu++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 -std=gnu++14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp17 -std=gnu++1z %s
 
 
 
 // Errors
 export class foo { };   // expected-error {{expected template}}
 template  x;            // expected-error {{a type specifier is required for all declarations}} \
                         // expected-error {{does not refer}}

clang/test/Parser/cxx1z-nested-namespace-definition.cpp

 // RUN: cp %s %t
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98
-// RUN: not %clang_cc1 -x c++ -fixit %t -Werror -DFIXIT
-// RUN: %clang_cc1 -x c++ %t -DFIXIT
+// RUN: not %clang_cc1 -x c++ -std=c++14 -fixit %t -Werror -DFIXIT
+// RUN: %clang_cc1 -x c++ -std=c++14 %t -DFIXIT
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -Wc++14-compat
 
 namespace foo1::foo2::foo3 {
 #if __cplusplus <= 201400L
 // expected-warning@-2 {{nested namespace definition is a C++17 extension; define each namespace separately}}
 #else
 // expected-warning@-4 {{nested namespace definition is incompatible with C++ standards before C++17}}
 #endif

clang/test/Sema/ms_class_layout.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s --strict-whitespace
 
 #pragma pack(push, 8)
 
 class B {
 public:
   virtual void b(){}
   int b_field;

clang/test/SemaCXX/MicrosoftExtensions.cpp

-// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
+// RUN: %clang_cc1 -std=c++14 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 -std=c++98 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
 // RUN: %clang_cc1 -std=c++11 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
-// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
+// RUN: %clang_cc1 -std=c++14 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -fms-compatibility -verify -DTEST3
 
 #if TEST1
 
 // MSVC allows type definition in anonymous union and struct
 struct A
 {
   union

clang/test/SemaCXX/PR12778.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 void operator delete() throw(void*); // expected-error{{'operator delete' must have at least one parameter}}
 void* allocate(int __n) {
    return ::operator new(__n);
 }
 

clang/test/SemaCXX/altivec.cpp

-// RUN: %clang_cc1 -target-feature +altivec -flax-vector-conversions=none -triple powerpc-unknown-unknown -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -target-feature +altivec -flax-vector-conversions=none -triple powerpc-unknown-unknown -fcxx-exceptions -verify -std=c++14 %s
 
 typedef int V4i __attribute__((vector_size(16)));
 
 void test_vec_step(vector short arg1) {
   vector bool char vbc;
   vector signed char vsc;
   vector unsigned char vuc;
   vector bool short vbs;

clang/test/SemaCXX/bool.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion %s
-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion \
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -Wno-constant-conversion %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -Wno-constant-conversion \
 // RUN:     -Wno-deprecated -Wdeprecated-increment-bool %s
 
 // Bool literals can be enum values.
 enum {
   ReadWrite = false,
   ReadOnly = true
 };
 

clang/test/SemaCXX/default2.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 void f(int i, int j, int k = 3);
 void f(int i, int j, int k);
 void f(int i, int j = 2, int k);
 void f(int i, int j, int k);
 void f(int i = 1, int j, int k);
 void f(int i, int j, int k);
 

clang/test/SemaCXX/exception-spec-no-exceptions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s
 // expected-no-diagnostics
 
 // Note that we're specifically excluding -fcxx-exceptions in the command line above.
 
 // That this should work even with -fobjc-exceptions is PR9358
 
 // PR7243: redeclarations
 namespace test0 {

clang/test/SemaCXX/exceptions.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify=expected,precxx17 -std=c++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify=expected,precxx17 -std=c++14 %s
 
 struct A; // expected-note 4 {{forward declaration of 'A'}}
 
 struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
 
 void trys() {
   int k = 42;
   try {
void f() {
     using namespace NA;
     using namespace NB;
     try {
     } catch (int S) { 
     }
   }
 }
 
+#if __cplusplus < 201703L
 namespace Decay {
   struct A {
     void f() throw (A[10]);
   };
 
   template<typename T> struct B {
     void f() throw (B[10]);
   };
#if __cplusplus <= 199711L
   // expected-note@-2 {{in instantiation of template class 'Decay::C<Decay::E[10]>' requested here}}
 #endif
 }
 
 void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}}
 #if __cplusplus <= 199711L
 // expected-warning@-2 {{rvalue references are a C++11 extension}}
 #endif
+#endif
 
 namespace HandlerInversion {
 struct B {};
 struct D : B {};
 struct D2 : D {};
 
 void f1() {
   try {
void f8() {
   } catch (B b) { // expected-note {{for type 'B'}}
   } catch (D &d) { // expected-warning {{exception of type 'D &' will be caught by earlier handler}}
   }
 }
 }
 
 namespace ConstVolatileThrow {
 struct S {
-  S() {}         // expected-note{{candidate constructor not viable}}
-  S(const S &s); // expected-note{{candidate constructor not viable}}
+  S() {}         // precxx17-note{{candidate constructor not viable}}
+  S(const S &s); // precxx17-note{{candidate constructor not viable}}
 };
 
 typedef const volatile S CVS;
 
 void f() {
-  throw CVS(); // expected-error{{no matching constructor for initialization}}
+  throw CVS(); // precxx17-error{{no matching constructor for initialization}}
 }
 }
 
 namespace ConstVolatileCatch {
 struct S {
   S() {}
   S(const volatile S &s);
 

clang/test/SemaCXX/expressions.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion -std=c++11 %s
 
 void choice(int);
 int choice(bool);
 
 void test() {
   // Result of ! must be type bool.
   int i = choice(!1);
 }
 
+#if __cplusplus < 201703L
 // rdar://8018252
 void f0() {
   extern void f0_1(int*);
   register int x;
 #if __cplusplus >= 201103L // C++11 or later
   // expected-warning@-2 {{'register' storage class specifier is deprecated}}
 #endif
   f0_1(&x);
 }
+#endif
 
 namespace test1 {
   template <class T> void bar(T &x) { T::fail(); }
   template <class T> void bar(volatile T &x) {}
 
   void test_ints() {
     volatile int x;
     bar(x = 5);

clang/test/SemaCXX/inline.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s -Wpre-c++17-compat
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17-compat -std=c++17 %s -Wpre-c++17-compat
 
 // Check that we don't allow illegal uses of inline
 // (checking C++-only constructs here)
 struct c {inline int a;}; // expected-error{{'inline' can only appear on functions}}
 
 void localVar() {
   inline int a; // expected-error{{inline declaration of 'a' not allowed in block scope}}
 }
 
 // Check that we warn appropriately.
 #if __cplusplus <= 201402L
 inline int a; // expected-warning{{inline variables are a C++17 extension}}
 #else
-inline int a; // expected-warning{{inline variables are incompatible with C++ standards before C++17}}
+inline int a; // cxx17-compat-warning{{inline variables are incompatible with C++ standards before C++17}}
 #endif

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 // This is a test for an egregious hack in Clang that works around
 // issues with GCC's evolution. libstdc++ 4.2.x uses __is_pod as an
 // identifier (to declare a struct template like the one below), while
 // GCC 4.3 and newer make __is_pod a keyword. Clang treats __is_pod as
 // a keyword *unless* it is introduced following the struct keyword.
 
 template<typename T>

clang/test/SemaCXX/linkage2.cpp

 }
 
 namespace test17 {
   namespace {
     struct I {
     };
   }
   template <typename T1, typename T2> void foo() {}
-  template <typename T, T x> void bar() {} // expected-note {{candidate function}}
+  template <typename T, T x> void bar() {}
+#if __cplusplus < 201703L
+  // expected-note@-2 {{candidate function}}
+#endif
   inline void *g() {
     struct L {
     };
     // foo<L, I>'s linkage should be the merge of UniqueExternalLinkage (or
     // InternalLinkage in c++11) and VisibleNoLinkage. The correct answer is
     // NoLinkage in both cases. This means that using foo<L, I> as a template
     // argument should fail.
-    return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >); // expected-error {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
+    return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >);
+#if __cplusplus < 201703L
+    // expected-error@-2 {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
+#endif
   }
   void h() {
     g();
   }
 }
 
 namespace test18 {
   template <typename T> struct foo {

clang/test/SemaCXX/member-pointer.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 struct A {};
 enum B { Dummy };
 namespace C {}
 struct D : A {};
 struct E : A {};
 struct F : D, E {};
 struct G : virtual D {};
 class H : A {}; // expected-note 2{{implicitly declared private here}}
 
 int A::*pdi1;
 int (::A::*pdi2);
 int (A::*pfi)(int);
-void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}
+void (*A::*ppfie)() throw();
+#if __cplusplus < 201703L
+// expected-error@-2 {{exception specifications are not allowed beyond a single level of indirection}}
+#endif
 
 int B::*pbi;
 #if __cplusplus <= 199711L // C++03 or earlier modes
 // expected-warning@-2 {{use of enumeration in a nested name specifier is a C++11 extension}}
 #endif
 // expected-error@-4 {{'pbi' does not point into a class}}
 int C::*pci; // expected-error {{'pci' does not point into a class}}
 void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}

clang/test/SemaCXX/missing-namespace-qualifier-typo-corrections.cpp

namespace realstd {
   class linkedlist { /* ... */ };
 }
 
 void f() {
   mylinkedlist v; // expected-error{{unknown type name 'mylinkedlist'; did you mean 'realstd::mylinkedlist'?}}
   nylinkedlist w; // expected-error{{unknown type name 'nylinkedlist'; did you mean 'realstd::mylinkedlist'?}}
 }
 
+#if __cplusplus < 201703L
 // Test case from http://llvm.org/bugs/show_bug.cgi?id=10318
 namespace llvm {
  template <typename T> class GraphWriter {}; // expected-note 3{{declared here}}
 }
 
 struct S {};
 void bar() {
  GraphWriter<S> x; //expected-error{{no template named 'GraphWriter'; did you mean 'llvm::GraphWriter'?}}
  (void)new llvm::GraphWriter; // expected-error {{use of class template 'llvm::GraphWriter' requires template arguments}}
  (void)new llvm::Graphwriter<S>; // expected-error {{no template named 'Graphwriter' in namespace 'llvm'; did you mean 'GraphWriter'?}}
 }
+#endif
 
 // If namespace prefixes and character edits have the same weight, correcting
 // "fimish" to "N::famish" would have the same edit distance as correcting
 // "fimish" to "Finish". The result would be no correction being suggested
 // unless one of the corrections is given precedence (e.g. by filtering out
 // suggestions with added namespace qualifiers).
 namespace N { void famish(int); }
 void Finish(int); // expected-note {{'Finish' declared here}}

clang/test/SemaCXX/static-data-member.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -w %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -w %s
 
 struct ABC {
   static double a;
   static double b;
   static double c;
   static double d;
   static double e;
   static double f;
 };
 
 double ABC::a = 1.0;
 extern double ABC::b = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
 static double ABC::c = 1.0;  // expected-error {{'static' can only be specified inside the class definition}}
 __private_extern__ double ABC::d = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
 auto double ABC::e = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
 register double ABC::f = 1.0; // expected-error {{static data member definition cannot specify a storage class}}

clang/test/SemaCXX/type-definition-in-specifier.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify -std=c++14 %s
 
 struct S0;
 struct S1;
 struct S2;
 struct S3;
 struct S4;
 struct S5;
 struct S6;

clang/test/SemaCXX/user-defined-conversions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 -std=c++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected -std=c++17 %s
 struct X {
   operator bool();
 };
 
 int& f(bool);
 float& f(int);
 
 void f_test(X x) {
void test_conversion(ConvertibleToBase ctb, ConvertibleToDerived ctd,
   Base b1 = ctb;
   Base b2(ctb);
   Base b3 = ctd;
   Base b4(ctd);
   Base b5 = ctfd;
 }
 
 struct X1 {
-  X1(X1&); // expected-note{{candidate constructor not viable: expects an lvalue for 1st argument}}
+  X1(X1&); // precxx17-note{{candidate constructor not viable: expects an lvalue for 1st argument}}
 };
 
 struct X2 {
   operator X1();
 };
 
 int &f(X1);
 float &f(...);
 
 void g(X2 b) {
-  int &ir = f(b); // expected-error{{no viable constructor copying parameter of type 'X1'}}
+  int &ir = f(b); // precxx17-error{{no viable constructor copying parameter of type 'X1'}}
 }
 
 namespace rdar10202900 {
   class A {
   public:
     A();
 
   private:
     A(int i); // expected-note{{declared private here}}
   };
 
   void testA(A a) {
     int b = 10;
     a = b; // expected-error{{calling a private constructor of class 'rdar10202900::A'}}
   }
 }

clang/test/SemaCXX/warn-new-overaligned-3.cpp

-// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify=precxx17 -std=c++14
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify -std=c++17
+
+// expected-no-diagnostics
 
 // This test ensures that we still get the warning even if we #include <new>
 // where the header here simulates <new>.
 #include <warn-new-overaligned-3.h>
 
 namespace test1 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test2 {
 struct helper { int i __attribute__((aligned(256))); };
 
 struct Placement {
   Placement() {
     new (d) helper();
   }
   helper *d;
 };
 }

clang/test/SemaCXX/warn-new-overaligned.cpp

-// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify %s
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify=precxx17 -std=c++14 %s
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify=cxx17 -std=c++17 %s
 
 namespace test1 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test2 {
 class Test {
   typedef int __attribute__((aligned(256))) aligned_int;
   aligned_int high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test3 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   void* operator new(unsigned long) {
-    return 0; // expected-warning {{'operator new' should not return a null pointer unless it is declared 'throw()'}}
+    return 0; // precxx17-warning {{'operator new' should not return a null pointer unless it is declared 'throw()'}} \
+                 cxx17-warning {{'operator new' should not return a null pointer unless it is declared 'throw()' or 'noexcept'}} 
   }
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
   new Test;
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test4 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   void* operator new[](unsigned long) {
-    return 0; // expected-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()'}}
+    return 0; // precxx17-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()'}} \
+                 cxx17-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()' or 'noexcept'}} 
   }
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
   new Test[10];
 }
 }

clang/test/SemaCXX/writable-strings-deprecated.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -DWARNING
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s -DWARNING
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s -DWARNING
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-deprecated-writable-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-deprecated -Wdeprecated-increment-bool -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -fwritable-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-write-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror=c++11-compat -verify %s -DERROR
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror=deprecated -Wno-error=deprecated-increment-bool -verify %s -DERROR
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s -DWARNING

clang/test/SemaSYCL/zero-length-arrays.cpp

-// RUN: %clang_cc1 -fsycl-is-device -triple spir64 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsycl-is-device -triple spir64 -fsyntax-only -verify -std=c++14 %s
 //
 // This test checks if compiler reports compilation error on an attempt to use
 // a zero-length array inside device code.
 
 template <typename Name, typename Func>
 __attribute__((sycl_kernel)) void kernel(const Func &kernelFunc) {
   // expected-note@+1 5{{called by 'kernel}}
   kernelFunc(); // #KernelObjCall

clang/test/SemaTemplate/class-template-id.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 template<typename T, typename U = float> struct A { };
 
 typedef A<int> A_int;
 
 typedef float FLOAT;
 
 A<int, FLOAT> *foo(A<int> *ptr, A<int> const *ptr2, A<int, double> *ptr3) {
   if (ptr)

clang/test/SemaTemplate/constructor-template.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 struct X0 { // expected-note {{candidate constructor (the implicit copy constructor) not viable}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
 #endif
   X0(int); // expected-note{{candidate}}

clang/test/SemaTemplate/explicit-instantiation.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions %s
 // RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -std=c++14 %s
 
 template void *; // expected-error{{expected unqualified-id}}
 
 template typedef void f0; // expected-error{{explicit instantiation of typedef}}
 
 int v0; // expected-note{{refers here}}
 template int v0; // expected-error{{does not refer}}
 

clang/test/SemaTemplate/instantiate-exception-spec.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %s -DERRORS
-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -emit-llvm-only %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify -std=c++14 %s -DERRORS
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -emit-llvm-only -std=c++14 %s
 
 #ifdef ERRORS
 template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}}
 struct Incomplete; // expected-note{{forward}}
 
 void test_f1(Incomplete *incomplete_p, int *int_p) {
   f1(int_p);
   f1(incomplete_p); // expected-note{{instantiation of}}

clang/test/SemaTemplate/instantiate-non-dependent-types.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 template<typename T>
 struct X1 {
   static void member() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 };
 
 template<void(*)()> struct instantiate { };
 

clang/test/SemaTemplate/instantiation-default-2.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 template<typename T, T Value> struct Constant; // expected-note{{template parameter is declared here}} \
 // FIXME: bad location expected-error{{a non-type template parameter cannot have type 'float'}}
 
 Constant<int, 5> *c1;
 
 int x;
 float f(int, double);

clang/test/SemaTemplate/temp_arg.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 template<typename T, 
          int I, 
          template<typename> class TT>
   class A; // expected-note 3 {{template is declared here}}
 
 template<typename> class X;
 
 A<int, 0, X> * a1;

clang/test/SemaTemplate/temp_arg_template.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
 
 template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}}
 
 template<template<int I> class X> struct C;  // expected-note 2{{previous non-type template parameter with type 'int' is here}}

clang/test/SemaTemplate/typename-specifier-3.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 // PR4364
 template<class T> struct a { // expected-note {{here}}
   T b() {
     return typename T::x();
   }
 };
 struct B {

clang/unittests/AST/ASTTraverserTest.cpp

)cpp");
   const auto ATL = TL.getNextTypeLoc().getAs<AttributedTypeLoc>();
   const auto *AS = cast<AddressSpaceAttr>(ATL.getAttr());
   EXPECT_EQ(toTargetAddressSpace(static_cast<LangAS>(AS->getAddressSpace())),
             19u);
 }
 
 TEST(Traverse, IgnoreUnlessSpelledInSourceVars) {
 
-  auto AST = buildASTFromCode(R"cpp(
+  auto AST = buildASTFromCodeWithArgs(R"cpp(
 
 struct String
 {
     String(const char*, int = -1) {}
 
     int overloaded() const;
     int& overloaded();
 };
void varDeclCtors() {
   auto var6 = TwoParamCtor(i, 7);
   }
   {
   OneParamCtor var7(i);
   TwoParamCtor var8(i, 7);
   }
 }
 
-)cpp");
+)cpp", {"-std=c++14"});
 
   {
     auto FN =
         ast_matchers::match(functionDecl(hasName("stringConstruct")).bind("fn"),
                             AST->getASTContext());
     EXPECT_EQ(FN.size(), 1u);
 
     EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("fn")),
`-CXXBindTemporaryExpr
       `-CallExpr
         `-ImplicitCastExpr
           `-DeclRefExpr 'someFun'
 )cpp");
 }
 
 TEST(Traverse, IgnoreUnlessSpelledInSourceReturns) {
 
-  auto AST = buildASTFromCode(R"cpp(
+  auto AST = buildASTFromCodeWithArgs(R"cpp(
 
 struct A
 {
 };
 
 struct B
 {
   B(int);
B func11() {
   return b;
 }
 
 B func12() {
   C c;
   return c;
 }
 
-)cpp");
+)cpp", {"-std=c++14"});
 
   auto getFunctionNode = [&AST](const std::string &name) {
     auto BN = ast_matchers::match(functionDecl(hasName(name)).bind("fn"),
                                   AST->getASTContext());
     EXPECT_EQ(BN.size(), 1u);
     return BN[0].getNodeAs<Decl>("fn");
   };