[Sema] Add deprecation warnings for some compiler provided __has_* type traits

[royjacobson]

Summary

Some compiler provided type traits like __has_trivial_constructor have been documented
as deprecated for quite some time.
Still, some people apparently still use them, even though mixing them with concepts
and with deleted functions leads to weird results. There's also disagreement about some
edge cases between GCC (which Clang claims to follow) and MSVC.

This patch adds deprecation warnings for the usage of those builtins, except for __has_trivial_destructor
which doesn't have a GCC alternative.

I made the warning on by default, so I had to silence it for some tests but it's not too many.

Some (decade old) history of issues with those builtins:
https://github.com/llvm/llvm-project/issues/18187
https://github.com/llvm/llvm-project/issues/18559
https://github.com/llvm/llvm-project/issues/22161
https://github.com/llvm/llvm-project/issues/33063

The abseil usage of them that triggered me to add this warning:
https://github.com/abseil/abseil-cpp/issues/1201

Weird interaction of those builtins with C++20's conditionally trivial special member functions:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106085

[cor3ntin]

clang/include/clang/Basic/DiagnosticSemaKinds.td

5561

Should we say something like "and will be removed in the future"?

"%0 is deprecated from C++11 onward. Use %1 instead." might be sufficient

clang/lib/Sema/SemaExprCXX.cpp

5432

[erichkeane]

clang/docs/ReleaseNotes.rst

305

306

clang/include/clang/Basic/DiagnosticSemaKinds.td

5561

Diagnostics arent sentences. Also, we wouldn't say "C++11 onward", we can just say C++11. I might suggest:

builtin %0 is deprecated in C++11, use %1 instead

BUT @aaron.ballman always does great at this level of bikeshedding.

clang/lib/Sema/SemaExprCXX.cpp

5445

[aaron.ballman]

clang/include/clang/Basic/DiagnosticGroups.td

190

I wonder if we want to rename this to deprecated-builtins so it applies to any builtin we elect to deprecate, not just ones that start with has. WDYT?

clang/include/clang/Basic/DiagnosticSemaKinds.td

5561

I think we might want to rename this to warn_deprecated_builtin and make it slightly more general. I think we want to drop the mention of C++11 because the documentation says these are deprecated (not deprecated in a specific version) and the replacement APIs are all available pre C++11 anyway (at least in Clang). How about: builtin %0 is deprecated; use %1 instead?

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

I think we should always warn on these, not just in C++11.

5426–5428

This one is not documented as being deprecated (or documented at all). I think it's reasonable to deprecate it, but it should probably be documented in the language extensions page.

5433

I'd like to know how plausible that "might" is -- Clang flags it as being deprecated, so it seems very reasonable to diagnose it as such. These diagnostics won't be triggered from system headers by default anyway, so I'm not certain if this will be too noisy in practice.

[royjacobson]

Address CR comments.
Make the switch case slightly more concise.

[royjacobson]

clang/include/clang/Basic/DiagnosticGroups.td

190

Sounds good to me, updated it.

clang/include/clang/Basic/DiagnosticSemaKinds.td

5561

Took Aaron's version at the end.

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

I'm not convinced we should. My reasoning is that we need a pretty good reason to start issuing warnings for 20 years old code. The usage of those builtins with deleted functions after C++11 is pretty broken which is a pretty good reason, but for earlier language versions they work 'fine' and if people want to use C++03 I prefer leaving them at peace :)

People on C++03 are also probably using pretty old versions of libstdc++ and/or boost type_traits, so this could have some impact.

WDYT?

5426–5428

It's the __has_trivial_constructor builtin that unfortunately has a different enum name (it's named after the internal CXXRecordDecl it calls, I think).

5433

It's used in libstdc++'s type_traits and in boost's type_traits (but we will start warning on boost's type_traits anyway). So it's even if by default people are not going to see it I think it's used widely enough to be problematic and we shouldn't warn on this for now.

I added the libstdc++ part to the comment as well.

[erichkeane]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

warnings don't get emitted for code in header files, so at least that part isn't a concern.

[royjacobson]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

Any header files, or just system headers?

[erichkeane]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

Sorry, yes, Phab is a mess on a cell phone... in things included as System Headers.

[aaron.ballman]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

Agreed with Erich -- warnings in system headers (but not regular headers) are silenced by default, you need to pass -Wsystem-headers to enable them.

5433

My feeling is: if it's deprecated and we don't warn on it, it's not actually deprecated. I'd rather see us warn uniformly on all the deprecated interfaces. System headers are free to keep using these interfaces (system headers are long lived), but any user code using this needs some sort of notification that they're using something we don't want them to use, or we will never be able to get rid of these interfaces (at which point, we should undeprecate them because we need to keep them working).

[royjacobson]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

To clarify my position, I think about those builtins as an unofficial part of the C++03 standard and I think we should support them as long as we support C++03.

Do you think that's reasonable?

I agree we should update the documentation in this case.

[aaron.ballman]

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

I still don't see the benefit of undeprecating these in C++03. The replacement interfaces are available for use in C++03 mode, so there's nothing that prevents a user from being pushed to use the supported interfaces instead, right? To me, the older interfaces were not clean/correct and the replacement interfaces are the ones that we want people to use, and that's language mode agnostic.

[royjacobson]

Warn on <=C++03 as well, warn on __has_trivial_destructor.

clang/lib/Sema/SemaExprCXX.cpp

5400–5401

I think they're

1. Clean enough under C++03 semantics - without the extra complications of move semantics, defaulted/deleted functions etc.
2. Potentially pretty widely used in code that needs C++03, though I have no idea how to check that.

But you convinced me that it's probably not that of a big deal to add those warnings anyway, so let's add them and think about actual deprecation in a few years :)

5433

Ok, added it to the warnings.

[aaron.ballman]

LGTM, thank you!

[glandium]

From the commit message:

This patch adds deprecation warnings for the usage of those builtins, except for __has_trivial_destructor which doesn't have a GCC alternative.

The exception for __has_trivial_destructor doesn't seem to be true, FWIW.

[royjacobson]

In D129170#3650618, @glandium wrote:

From the commit message:

This patch adds deprecation warnings for the usage of those builtins, except for __has_trivial_destructor which doesn't have a GCC alternative.

The exception for __has_trivial_destructor doesn't seem to be true, FWIW.

Oh, I'm really sorry for that :/ It was changed because Aaron asked me to add it as well, but I forgot to update the summary.

clang/docs/ReleaseNotes.rst

- Improve __builtin_dump_struct:
   - Support formatting of base classes in C++.
   - Support calling a formatting function template in C++, which can provide
     custom formatting for non-aggregate types.
 
 - Previously disabled sanitizer options now enabled by default:
   - ASAN_OPTIONS=detect_stack_use_after_return=1 (only on Linux).
   - MSAN_OPTIONS=poison_in_dtor=1.
 
+- Some type-trait builtins, such as ``__has_trivial_assign``, have been documented
+  as deprecated for a while because their semantics don't mix well with post-C++11 type-traits.
+  Clang now emits deprecation warnings for them under the flag ``-Wdeprecated-builtins``.
+
 New Compiler Flags
 ------------------
 - Added the ``-fno-knr-functions`` flag to allow users to opt into the C2x
   behavior where a function with an empty parameter list is treated as though
   the parameter list were ``void``. There is no ``-fknr-functions`` or
   ``-fno-no-knr-functions`` flag; this feature cannot be disabled in language
   modes where it is required, such as C++ or C2x.
 - A new ARM pass to workaround Cortex-A57 Erratum 1742098 and Cortex-A72 Erratum

clang/include/clang/Basic/DiagnosticGroups.td

 def UnavailableDeclarations : DiagGroup<"unavailable-declarations">;
 def UnguardedAvailabilityNew : DiagGroup<"unguarded-availability-new">;
 def UnguardedAvailability : DiagGroup<"unguarded-availability",
                                       [UnguardedAvailabilityNew]>;
 // partial-availability is an alias of unguarded-availability.
 def : DiagGroup<"partial-availability", [UnguardedAvailability]>;
 def DeprecatedDynamicExceptionSpec
     : DiagGroup<"deprecated-dynamic-exception-spec">;
+def DeprecatedBuiltins : DiagGroup<"deprecated-builtins">;
 def DeprecatedImplementations :DiagGroup<"deprecated-implementations">;
 def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">;
 def DeprecatedRegister : DiagGroup<"deprecated-register">;
 def DeprecatedThisCapture : DiagGroup<"deprecated-this-capture">;
 def DeprecatedVolatile : DiagGroup<"deprecated-volatile">;
 def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings",
                                       [CXX11CompatDeprecatedWritableStr]>;
 def DeprecatedPragma : DiagGroup<"deprecated-pragma">;
 def DeprecatedType : DiagGroup<"deprecated-type">;
 // FIXME: Why is DeprecatedImplementations not in this group?
 def Deprecated : DiagGroup<"deprecated", [DeprecatedAnonEnumEnumConversion,
                                           DeprecatedArrayCompare,
                                           DeprecatedAttributes,
                                           DeprecatedCommaSubscript,
                                           DeprecatedCopy,
                                           DeprecatedCopyWithDtor,
                                           DeprecatedDeclarations,
                                           DeprecatedDynamicExceptionSpec,
                                           DeprecatedEnumCompare,
                                           DeprecatedEnumCompareConditional,
                                           DeprecatedEnumEnumConversion,
                                           DeprecatedEnumFloatConversion,
+                                          DeprecatedBuiltins,
                                           DeprecatedIncrementBool,
                                           DeprecatedPragma,
                                           DeprecatedRegister,
                                           DeprecatedThisCapture,
                                           DeprecatedType,
                                           DeprecatedVolatile,
                                           DeprecatedWritableStr]>,
                  DiagCategory<"Deprecations">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_deprecated_fwdclass_message : Warning<
     "%0 may be deprecated because the receiver type is unknown">,
     InGroup<DeprecatedDeclarations>;
 def warn_deprecated_def : Warning<
   "implementing deprecated %select{method|class|category}0">,
   InGroup<DeprecatedImplementations>, DefaultIgnore;
 def warn_unavailable_def : Warning<
   "implementing unavailable method">,
   InGroup<DeprecatedImplementations>, DefaultIgnore;
+def warn_deprecated_builtin : Warning<
+  "builtin %0 is deprecated; use %1 instead">,
+  InGroup<DeprecatedBuiltins>;
 def err_unavailable : Error<"%0 is unavailable">;
 def err_property_method_unavailable :
     Error<"property access is using %0 method which is unavailable">;
 def err_unavailable_message : Error<"%0 is unavailable: %1">;
 def warn_unavailable_fwdclass_message : Warning<
     "%0 may be unavailable because the receiver type is unknown">,
     InGroup<UnavailableDeclarations>;
 def note_availability_specified_here : Note<

clang/lib/Sema/SemaExprCXX.cpp

case clang::TT_IsTriviallyConstructible: {
     return false;
   }
     default: llvm_unreachable("not a TT");
   }
 
   return false;
 }
 
+namespace {
+void DiagnoseBuiltinDeprecation(Sema& S, TypeTrait Kind,
+                                SourceLocation KWLoc) {
+  if (!S.getLangOpts().CPlusPlus11)
+    return;
+
+  TypeTrait Replacement;
+  switch (Kind) {
+    case UTT_HasNothrowAssign:
+    case UTT_HasNothrowMoveAssign:
+      Replacement = BTT_IsNothrowAssignable;
+      break;
+    case UTT_HasNothrowCopy:
+    case UTT_HasNothrowConstructor:
+      Replacement = TT_IsNothrowConstructible;
+      break;
+    case UTT_HasTrivialAssign:
+    case UTT_HasTrivialMoveAssign:
+      Replacement = BTT_IsTriviallyAssignable;
+      break;
+    case UTT_HasTrivialCopy:
+    case UTT_HasTrivialDefaultConstructor:
+    case UTT_HasTrivialMoveConstructor:
+      Replacement = TT_IsTriviallyConstructible;
+      break;
+    // FIXME: GCC doesn't implement __is_trivially_destructible: Warning for this
+    //   might be too noisy for now as this is used to implement std::is_trivially_destructible
+    //   in libstdc++.
+    // case UTT_HasTrivialDestructor:
+    //   Replacement = UTT_IsTriviallyDestructible;
+    //   break;
+    default:
+      return;
+  }
+  S.Diag(KWLoc, diag::warn_deprecated_has_builtins)
+    << getTraitSpelling(Kind) << getTraitSpelling(Replacement);
+}
+}
+
 ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
                                 ArrayRef<TypeSourceInfo *> Args,
                                 SourceLocation RParenLoc) {
   QualType ResultType = Context.getLogicalOperationType();
 
   if (Kind <= UTT_Last && !CheckUnaryTypeTraitTypeCompleteness(
                                *this, Kind, KWLoc, Args[0]->getType()))
     return ExprError();
 
+  DiagnoseBuiltinDeprecation(*this, Kind, KWLoc);
+
   bool Dependent = false;
   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
     if (Args[I]->getType()->isDependentType()) {
       Dependent = true;
       break;
     }
   }
 

clang/test/CXX/dcl.decl/dcl.init/p5.cpp

 // 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
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-deprecated-builtins -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-deprecated-builtins %s
 
 //   A program that calls for default-initialization or value-initialization of
 //   an entity of reference type is illformed. If T is a cv-qualified type, the
 //   cv-unqualified version of T is used for these definitions of
 //   zero-initialization, default-initialization, and value-initialization.
 
 typedef int &IR;
 IR r; // expected-error {{declaration of reference variable 'r' requires an initializer}}

clang/test/CXX/drs/dr18xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2a -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus < 201103L
 // expected-error@+1 {{variadic macro}}
 #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
 #endif
 
 namespace dr1813 { // dr1813: 7
   struct B { int i; };

clang/test/CXX/drs/dr21xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus < 201103L
 // expected-error@+1 {{variadic macro}}
 #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
 #endif
 
 namespace dr2100 { // dr2100: 12
   template<const int *P, bool = true> struct X {};

clang/test/CXX/special/class.copy/p12-0x.cpp

-// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-defaulted-function-deleted
-// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-defaulted-function-deleted -fclang-abi-compat=14 -DCLANG_ABI_COMPAT=14
+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-deprecated-builtins -Wno-defaulted-function-deleted
+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-deprecated-builtins -Wno-defaulted-function-deleted -fclang-abi-compat=14 -DCLANG_ABI_COMPAT=14
 
 // expected-no-diagnostics
 
 template<typename T, bool B> struct trivially_copyable_check {
   static_assert(B == __has_trivial_copy(T), "");
   static_assert(B == __is_trivially_constructible(T, T), "");
   static_assert(B == __is_trivially_constructible(T, const T &), "");
   static_assert(B == __is_trivially_constructible(T, T &&), "");

clang/test/CXX/special/class.copy/p25-0x.cpp

-// RUN: %clang_cc1 -std=c++11 -verify %s
-// RUN: %clang_cc1 -std=c++11 -verify %s -fclang-abi-compat=14 -DCLANG_ABI_COMPAT=14
+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-deprecated-builtins
+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-deprecated-builtins -fclang-abi-compat=14 -DCLANG_ABI_COMPAT=14
 
 // expected-no-diagnostics
 
 template<typename T, bool B> struct trivially_assignable_check {
   static_assert(B == __has_trivial_assign(T), "");
   static_assert(B == __is_trivially_assignable(T&, T), "");
   static_assert(B == __is_trivially_assignable(T&, const T &), "");
   static_assert(B == __is_trivially_assignable(T&, T &&), "");

clang/test/CXX/special/class.ctor/p5-0x.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-defaulted-function-deleted
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-deprecated-builtins -Wno-defaulted-function-deleted
 
 struct DefaultedDefCtor1 {};
 struct DefaultedDefCtor2 { DefaultedDefCtor2() = default; };
 struct DefaultedDefCtorUninitialized1 { int x; };
 struct DefaultedDefCtorUninitialized2 { int x; DefaultedDefCtorUninitialized2() = default; };
 struct DeletedDefCtor { DeletedDefCtor() = delete; DeletedDefCtor(int); }; // expected-note {{explicitly marked deleted here}}
 class PrivateDefCtor { PrivateDefCtor() = default; public: PrivateDefCtor(int); };
 struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 4{{explicitly marked deleted here}}

clang/test/Modules/cxx-decls.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11
-// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -ast-dump -ast-dump-filter merge -std=c++11 | FileCheck %s
+// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Wno-deprecated-builtins -I %S/Inputs %s -verify -std=c++11
+// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Wno-deprecated-builtins -I %S/Inputs %s -ast-dump -ast-dump-filter merge -std=c++11 | FileCheck %s
 
 // expected-no-diagnostics
 
 void use_implicit_new() { operator new[](3); }
 
 @import dummy;
 @import cxx_decls.imported;
 

clang/test/SemaCXX/cxx0x-defaulted-functions.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fcxx-exceptions %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fcxx-exceptions -Wno-deprecated-builtins %s
 
 void fn() = default; // expected-error {{only special member}}
 struct foo {
   void fn() = default; // expected-error {{only special member}}
 
   foo() = default;
   foo(const foo&) = default;
   foo(foo&&) = default;

clang/test/SemaCXX/cxx11-crashes.cpp

-// RUN: %clang_cc1 -std=c++11 -verify %s
+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-deprecated-builtins
 
 // rdar://12240916 stack overflow.
 namespace rdar12240916 {
 
 struct S2 {
   S2(const S2&);
   S2();
 };

clang/test/SemaCXX/deprecated-builtins.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct A {};
+
+void f() {
+    bool a;
+
+    a = __has_nothrow_assign(A);  // expected-warning-re {{the __has_nothrow_assign {{.*}} Use __is_nothrow_assignable}}
+    a = __has_nothrow_move_assign(A);  // expected-warning-re {{the __has_nothrow_move_assign {{.*}} Use __is_nothrow_assignable}}
+    a = __has_nothrow_copy(A);  // expected-warning-re {{the __has_nothrow_copy {{.*}} Use __is_nothrow_constructible}}
+    a = __has_nothrow_constructor(A);  // expected-warning-re {{the __has_nothrow_constructor {{.*}} Use __is_nothrow_constructible}}
+    a = __has_trivial_assign(A);  // expected-warning-re {{the __has_trivial_assign {{.*}} Use __is_trivially_assignable}}
+    a = __has_trivial_move_assign(A);  // expected-warning-re {{the __has_trivial_move_assign {{.*}} Use __is_trivially_assignable}}
+    a = __has_trivial_copy(A);  // expected-warning-re {{the __has_trivial_copy {{.*}} Use __is_trivially_constructible}}
+    a = __has_trivial_constructor(A);  // expected-warning-re {{the __has_trivial_constructor {{.*}} Use __is_trivially_constructible}}
+    a = __has_trivial_move_constructor(A);  // expected-warning-re {{the __has_trivial_move_constructor {{.*}} Use __is_trivially_constructible}}
+    a = __has_trivial_destructor(A);
+
+}

clang/test/SemaCXX/sizeless-1.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++98 %s
-// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++11 %s
-// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++17 %s
-// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++17 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++17 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++17 %s
 
 namespace std {
 struct type_info;
 }
 
 typedef __SVInt8_t svint8_t;
 typedef __SVInt16_t svint16_t;
 

clang/test/SemaCXX/trivial-constructor.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-deprecated-builtins
 // expected-no-diagnostics
 struct T1 {
 };
 static_assert(__has_trivial_constructor(T1), "T1 has trivial constructor!");
 
 struct T2 {
   T2();
 };

clang/test/SemaCXX/trivial-destructor.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wno-deprecated-builtins
 // expected-no-diagnostics
 struct T1 {
 };
 static_assert(__has_trivial_destructor(T1), "T1 has trivial destructor!");
 
 struct T2 {
   ~T2();
 };

clang/test/SemaCXX/type-traits.cpp

-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
 
 #define T(b) (b) ? 1 : -1
 #define F(b) (b) ? -1 : 1
 
 struct NonPOD { NonPOD(int); };
 typedef NonPOD NonPODAr[10];
 typedef NonPOD NonPODArNB[];
 typedef NonPOD NonPODArMB[10][2];

clang/test/SemaObjCXX/arc-type-traits.mm

-// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify -std=c++11 %s -Wno-deprecated-builtins
 // expected-no-diagnostics
 
 // Check the results of the various type-trait query functions on
 // lifetime-qualified types in ARC.
 
 #define JOIN3(X,Y) X ## Y
 #define JOIN2(X,Y) JOIN3(X,Y)
 #define JOIN(X,Y) JOIN2(X,Y)

clang/test/SemaObjCXX/objc-weak-type-traits.mm

-// RUN: %clang_cc1 -fsyntax-only -fobjc-weak -fobjc-runtime-has-weak -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-weak -fobjc-runtime-has-weak -verify -std=c++11 %s -Wno-deprecated-builtins
 // expected-no-diagnostics
 
 // Check the results of the various type-trait query functions on
 // lifetime-qualified types in ObjC Weak.
 
 #define TRAIT_IS_TRUE(Trait, Type) static_assert(Trait(Type), "")
 #define TRAIT_IS_FALSE(Trait, Type) static_assert(!Trait(Type), "")
 #define TRAIT_IS_TRUE_2(Trait, Type1, Type2) static_assert(Trait(Type1, Type2), "")