Explicitly add language standard option to test cases that rely on the C++14 default

[nemanjai]

Summary

One of the platforms on which we do regular builds has some system headers that are not compatible with C++14. As a result, we can't compile any code (including test-suite tests) if we leave the default as is. So what we do is set the CMake option that allows us to set clang's default language level (we set it to gnu++11 in our case). However, this causes failures in all of the lit tests attached.

This patch simply adds the -std=gnu++14 option to match the typical default for clang that the test cases rely on.

I've tried to add people that have added/modified the tests as reviewers to this patch - so I am sorry about the very long list of reviewers. Please let me know if this is an acceptable change.

[erichkeane]

This seems innocuous to me. I don't see any problem with it, but please don't commit until the others have had time to look.

[ilya-biryukov]

The change looks reasonable to me, given that you can change the default language version via a build argument.
I don't have the required experience with the lit-tests to give proper approval, though, would wait for someone more relevant to do this.

Do have a comment, though. Any, reason to use -std=gnu++14 and not -std=c++14?
Most (all?) of the tests do not seem to have anything to do with the gnu extensions, so why enable them?

[nemanjai]

In D57581#1380609, @ilya-biryukov wrote:

...
Do have a comment, though. Any, reason to use -std=gnu++14 and not -std=c++14?
Most (all?) of the tests do not seem to have anything to do with the gnu extensions, so why enable them?

I only used gnu++14 in the test cases to match the current default in clang (i.e. not change how clang handles the test case). But I have no problem whatsoever with making these standard C++.

[rjmccall]

I agree: if a test doesn't seem to require the GNU extensions, let's not use -std=gnu++XX. Otherwise this LGTM.

[nemanjai]

Changed the option to standard C++ rather than GNU extensions.

[ilya-biryukov]

LGTM. I think it's fine to land it, since no-one raised any concerns so far.

test/CodeCompletion/crash-skipped-bodies-template-inst.cpp

-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:24:5 %s -o - 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -std=gnu++14 -code-completion-at=%s:24:5 %s -o - 2>&1 | FileCheck %s
 template <class T>
 auto make_func() {
   struct impl {
     impl* func() {
       int x;
       if (x = 10) {}
       // Check that body of this function is actually skipped.
       // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a condition without parentheses

test/CodeCompletion/skip-auto-funcs.cpp

 // We run clang in completion mode to force skipping of function bodies and
 // check if the function bodies were skipped by observing the warnings that
 // clang produces.
-// RUN: not %clang_cc1 -fsyntax-only -code-completion-at=%s:60:1 %s -o - 2>&1 | FileCheck %s
+// RUN: not %clang_cc1 -std=gnu++14 -fsyntax-only -code-completion-at=%s:60:1 %s -o - 2>&1 | FileCheck %s
 template <class T>
 auto not_skipped() {
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
   // CHECK: 8:9: warning: using the result of an assignment as a condition without parentheses
   return 1;
 }

test/CodeGenCXX/auto-var-init.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fblocks %s -emit-llvm -o - | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=pattern %s -emit-llvm -o - | FileCheck %s -check-prefix=PATTERN
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -emit-llvm -o - | FileCheck %s -check-prefix=ZERO
+// RUN: %clang_cc1 -std=gnu++14 -triple x86_64-unknown-unknown -fblocks %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=gnu++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=pattern %s -emit-llvm -o - | FileCheck %s -check-prefix=PATTERN
+// RUN: %clang_cc1 -std=gnu++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -emit-llvm -o - | FileCheck %s -check-prefix=ZERO
 
 template<typename T> void used(T &) noexcept;
 
 #define TEST_UNINIT(NAME, TYPE)                 \
   using type_##NAME = TYPE;                     \
   void test_##NAME##_uninit() {                 \
     type_##NAME uninit;                         \
     used(uninit);                               \

test/CodeGenCXX/dllexport-no-dllexport-inlines.cpp

 // RUN: %clang_cc1 %s -fms-extensions -triple x86_64-windows-msvc       \
-// RUN:     -disable-llvm-passes                                        \
+// RUN:     -disable-llvm-passes -std=gnu++14                           \
 // RUN:     -fno-dllexport-inlines -emit-llvm -O1 -o - |                \
 // RUN:     FileCheck --check-prefix=CHECK --check-prefix=NOEXPORTINLINE %s
 
 // RUN: %clang_cc1 %s -fms-extensions -triple x86_64-windows-msvc       \
-// RUN:     -disable-llvm-passes                                        \
+// RUN:     -disable-llvm-passes -std=gnu++14                           \
 // RUN:     -emit-llvm -O1 -o - |                                       \
 // RUN:     FileCheck --check-prefix=CHECK  --check-prefix=EXPORTINLINE %s
 
 
 struct __declspec(dllexport) ExportedClass {
 
   // NOEXPORTINLINE-DAG: define linkonce_odr dso_local void @"?InclassDefFunc@ExportedClass@@
   // EXPORTINLINE-DAG: define weak_odr dso_local dllexport void @"?InclassDefFunc@ExportedClass@@

test/CodeGenCXX/new-overflow.cpp

-// RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=gnu++14 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 
 // rdar://problem/9246208
 
 // Basic test.
 namespace test0 {
   struct A {
     A();
     int x;

test/CodeGenCXX/new.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -std=gnu++14 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 
 typedef __typeof__(sizeof(0)) size_t;
 
 // Declare an 'operator new' template to tickle a bug in __builtin_operator_new.
 template<typename T> void *operator new(size_t, int (*)(T));
 
 // Ensure that this declaration doesn't cause operator new to lose its
 // 'noalias' attribute.

test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++2a -fcxx-exceptions -fsized-deallocation -verify %s
 //
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -frelaxed-template-template-args -DRELAXED_TEMPLATE_TEMPLATE_ARGS=1 -verify %s
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
-// RUN: %clang_cc1 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
-// RUN: %clang_cc1 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
-// RUN: %clang_cc1 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
+// RUN: %clang_cc1 -std=gnu++14 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
+// RUN: %clang_cc1 -std=gnu++14 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
+// RUN: %clang_cc1 -std=gnu++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
 // RUN: %clang_cc1 -std=c++2a -fno-char8_t -DNO_EXCEPTIONS -DNO_CHAR8_T -verify -fsized-deallocation %s
 
 // expected-no-diagnostics
 
 // FIXME using `defined` in a macro has undefined behavior.
 #if __cplusplus < 201103L
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20) (cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98)
 #elif __cplusplus < 201402L

test/Lexer/half-literal.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -triple aarch64-linux-gnu %s
+// RUN: %clang_cc1 -std=gnu++14 -fsyntax-only -verify -pedantic -triple aarch64-linux-gnu %s
 float a = 1.0h; // expected-error{{no matching literal operator for call to 'operator""h' with argument of type 'long double' or 'const char *', and no matching literal operator template}}
 float b = 1.0H; // expected-error{{invalid suffix 'H' on floating constant}}
 
 _Float16 c = 1.f166; // expected-error{{invalid suffix 'f166' on floating constant}}
 _Float16 d = 1.f1;   // expected-error{{invalid suffix 'f1' on floating constant}}

test/Modules/friend-definition-2.cpp

-// RUN: %clang_cc1 -fmodules %s -verify
-// RUN: %clang_cc1 -fmodules %s -verify -triple i686-windows
+// RUN: %clang_cc1 -std=gnu++14 -fmodules %s -verify
+// RUN: %clang_cc1 -std=gnu++14 -fmodules %s -verify -triple i686-windows
 // expected-no-diagnostics
 #pragma clang module build A
 module A {}
 #pragma clang module contents
 #pragma clang module begin A
 template<typename T> struct ct { friend auto operator-(ct, ct) { struct X {}; return X(); } void x(); };
 #pragma clang module end
 #pragma clang module endbuild

test/Modules/merge-lambdas.cpp

-// RUN: %clang_cc1 -fmodules -verify %s -emit-llvm-only
+// RUN: %clang_cc1 -std=gnu++14 -fmodules -verify %s -emit-llvm-only
 // expected-no-diagnostics
 
 #pragma clang module build A
 module A {}
 #pragma clang module contents
 #pragma clang module begin A
 template<typename T> auto f() { return []{}; }
 #pragma clang module end

test/SemaCXX/int-ptr-cast-SFINAE.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=gnu++14
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17
 
 void foo(int* a, int *b) {
   a -= b; // expected-warning {{incompatible integer to pointer conversion assigning to 'int *' from}}
 }
 
 template<typename T> T declval();
 struct true_type { static const bool value = true; };

test/SemaTemplate/argument-dependent-lookup.cpp

-// RUN: %clang_cc1 -verify %s
-// RUN: %clang_cc1 -verify %s -DHAVE_UNQUALIFIED_LOOKUP_RESULTS
+// RUN: %clang_cc1 -std=gnu++14 -verify %s
+// RUN: %clang_cc1 -std=gnu++14 -verify %s -DHAVE_UNQUALIFIED_LOOKUP_RESULTS
 // expected-no-diagnostics
 
 namespace address_of {
 #ifdef HAVE_UNQUALIFIED_LOOKUP_RESULTS
   struct Q {};
   void operator&(Q);
 #endif
 

test/SemaTemplate/class-template-decl.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=gnu++14 -fsyntax-only -verify %s
 
 template<typename T> class A;
 
 extern "C++" {
   template<typename T> class B;
 }
 
 namespace N {

test/SemaTemplate/typo-dependent-name.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=gnu++14 -fsyntax-only -verify %s
 
 using nullptr_t = decltype(nullptr);
 
 template<typename T>
 struct Base {
   T inner;
 };