[clang] makes `__is_destructible` KEYALL instead of KEYMS

[cjdb]

Summary

This makes it possible to be used in all modes, instead of just when
-fms-extensions is enabled. Also moves the -fms-extensions-exclusive
traits into their own file so we can check the others aren't dependent
on this flag.

This is information that the compiler already has, and should be exposed
so that the library doesn't need to reimplement the exact same
functionality.

This was originally a part of D116280.

Depends on D135177.

[erichkeane]

This doesn't cause us to lose this in Microsoft C mode, does it? Otherwise, LGTM.

[cjdb]

In D135339#3839876, @erichkeane wrote:

This doesn't cause us to lose this in Microsoft C mode, does it? Otherwise, LGTM.

Why is destructibility necessary in C?

[erichkeane]

In D135339#3840323, @cjdb wrote:

In D135339#3839876, @erichkeane wrote:

This doesn't cause us to lose this in Microsoft C mode, does it? Otherwise, LGTM.

Why is destructibility necessary in C?

It isn't particularly? But I don't want to change our behavior and break code if:

// foo.h
struct S{};
bool get_thing() {
return __is_destructible(S);
}

someone runs that in C mode, expecting it to work.

[cjdb]

In D135339#3840406, @erichkeane wrote:

In D135339#3840323, @cjdb wrote:

In D135339#3839876, @erichkeane wrote:

This doesn't cause us to lose this in Microsoft C mode, does it? Otherwise, LGTM.

Why is destructibility necessary in C?

It isn't particularly? But I don't want to change our behavior and break code if:

// foo.h
struct S{};
bool get_thing() {
return __is_destructible(S);
}

someone runs that in C mode, expecting it to work.

Right, I can add a C test if it passed in C mode before. Do you want that in a separate file, or can I get away with doing it in type-traits-ms.cpp?

[erichkeane]

In D135339#3840422, @cjdb wrote:

In D135339#3840406, @erichkeane wrote:

In D135339#3840323, @cjdb wrote:

In D135339#3839876, @erichkeane wrote:

This doesn't cause us to lose this in Microsoft C mode, does it? Otherwise, LGTM.

Why is destructibility necessary in C?

It isn't particularly? But I don't want to change our behavior and break code if:

// foo.h
struct S{};
bool get_thing() {
return __is_destructible(S);
}

someone runs that in C mode, expecting it to work.

Right, I can add a C test if it passed in C mode before. Do you want that in a separate file, or can I get away with doing it in type-traits-ms.cpp?

No need for a separate file, just the -x c sorta flag is fine for me.

[cjdb]

applies feedback, rebases

clang/docs/LanguageExtensions.rst

* ``__is_complete_type(type)`` (Embarcadero):
   Warning: this trait is dangerous because it can return different values at
   different points in the same program.
 * ``__is_compound`` (C++, Embarcadero)
 * ``__is_const`` (C++, Embarcadero)
 * ``__is_constructible`` (C++, MSVC 2013)
 * ``__is_convertible`` (C++, Embarcadero)
 * ``__is_convertible_to`` (Microsoft):
   Synonym for ``__is_convertible``.
-* ``__is_destructible`` (C++, MSVC 2013):
-  Only available in ``-fms-extensions`` mode.
+* ``__is_destructible`` (C++, MSVC 2013)
 * ``__is_empty`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_enum`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_final`` (C++, GNU, Microsoft)
 * ``__is_floating_point`` (C++, Embarcadero)
 * ``__is_function`` (C++, Embarcadero)
 * ``__is_fundamental`` (C++, Embarcadero)
 * ``__is_integral`` (C++, Embarcadero)
 * ``__is_interface_class`` (Microsoft):
   Returns ``false``, even for types defined with ``__interface``.
 * ``__is_literal`` (Clang):
   Synonym for ``__is_literal_type``.
 * ``__is_literal_type`` (C++, GNU, Microsoft):
   Note, the corresponding standard trait was deprecated in C++17
   and removed in C++20.
 * ``__is_lvalue_reference`` (C++, Embarcadero)
 * ``__is_member_object_pointer`` (C++, Embarcadero)
 * ``__is_member_function_pointer`` (C++, Embarcadero)
 * ``__is_member_pointer`` (C++, Embarcadero)
 * ``__is_nothrow_assignable`` (C++, MSVC 2013)
 * ``__is_nothrow_constructible`` (C++, MSVC 2013)
 * ``__is_nothrow_destructible`` (C++, MSVC 2013)
-  Only available in ``-fms-extensions`` mode.
 * ``__is_nullptr`` (C++, GNU, Microsoft, Embarcadero):
   Returns true for ``std::nullptr_t`` and false for everything else. The
   corresponding standard library feature is ``std::is_null_pointer``, but
   ``__is_null_pointer`` is already in use by some implementations.
 * ``__is_object`` (C++, Embarcadero)
 * ``__is_pod`` (C++, GNU, Microsoft, Embarcadero):
   Note, the corresponding standard trait was deprecated in C++20.
 * ``__is_pointer`` (C++, Embarcadero)

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__FUNCDNAME__               , KEYMS)
 KEYWORD(__FUNCSIG__                 , KEYMS)
 KEYWORD(L__FUNCTION__               , KEYMS)
 KEYWORD(L__FUNCSIG__                , KEYMS)
 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS)
 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
 
 // MSVC12.0 / VS2013 Type Traits
-TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS)
+TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYALL)
 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX)
-TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS)
+TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYALL)
 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX)
 
 // MSVC14.0 / VS2015 Type Traits
 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
 
 // MSVC Type Traits of unknown vintage

clang/test/SemaCXX/type-traits-ms-extensions.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s -Wno-c++17-extensions
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s -Wno-c++17-extensions
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -x c -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+
+#ifdef __cplusplus
+
+// expected-no-diagnostics
+
+using Int = int;
+
+struct NonPOD { NonPOD(int); };
+enum Enum { EV };
+struct POD { Enum e; int i; float f; NonPOD* p; };
+struct Derives : POD {};
+using ClassType = Derives;
+
+union Union { int i; float f; };
+
+struct HasAnonymousUnion {
+  union {
+    int i;
+    float f;
+  };
+};
+
+struct FinalClass final {
+};
+
+template<typename T>
+struct PotentiallyFinal { };
+
+template<typename T>
+struct PotentiallyFinal<T*> final { };
+
+template<>
+struct PotentiallyFinal<int> final { };
+
+struct SealedClass sealed {
+};
+
+template<typename T>
+struct PotentiallySealed { };
+
+template<typename T>
+struct PotentiallySealed<T*> sealed { };
+
+template<>
+struct PotentiallySealed<int> sealed { };
+
+void is_final() {
+  static_assert(__is_final(SealedClass));
+  static_assert(__is_final(PotentiallySealed<float*>));
+  static_assert(__is_final(PotentiallySealed<int>));
+
+  static_assert(!__is_final(PotentiallyFinal<float>));
+  static_assert(!__is_final(PotentiallySealed<float>));
+}
+
+void is_sealed()
+{
+  static_assert(__is_sealed(SealedClass));
+  static_assert(__is_sealed(PotentiallySealed<float*>));
+  static_assert(__is_sealed(PotentiallySealed<int>));
+  static_assert(__is_sealed(FinalClass));
+  static_assert(__is_sealed(PotentiallyFinal<float*>));
+  static_assert(__is_sealed(PotentiallyFinal<int>));
+
+  static_assert(!__is_sealed(int));
+  static_assert(!__is_sealed(Union));
+  static_assert(!__is_sealed(Int));
+  static_assert(!__is_sealed(Int[10]));
+  static_assert(!__is_sealed(Union[10]));
+  static_assert(!__is_sealed(Derives));
+  static_assert(!__is_sealed(ClassType));
+  static_assert(!__is_sealed(const void));
+  static_assert(!__is_sealed(Int[]));
+  static_assert(!__is_sealed(HasAnonymousUnion));
+  static_assert(!__is_sealed(PotentiallyFinal<float>));
+  static_assert(!__is_sealed(PotentiallySealed<float>));
+}
+#else
+struct s1 {};
+
+void is_destructible()
+{
+  (void)__is_destructible(int);
+  (void)__is_destructible(struct s1);
+  (void)__is_destructible(struct s2); // expected-error{{incomplete type 'struct s2' used in type trait expression}}
+  // expected-note@-1{{}}
+}
+#endif

clang/test/SemaCXX/type-traits.cpp

-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins %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];

 struct PotentiallyFinal { };
 
 template<typename T>
 struct PotentiallyFinal<T*> final { };
 
 template<>
 struct PotentiallyFinal<int> final { };
 
-struct SealedClass sealed {
-};
 
-template<typename T>
-struct PotentiallySealed { };
 
-template<typename T>
-struct PotentiallySealed<T*> sealed { };
 
-template<>
-struct PotentiallySealed<int> sealed { };
 
 void is_final()
 {
-  { int arr[T(__is_final(SealedClass))]; }
-  { int arr[T(__is_final(PotentiallySealed<float*>))]; }
-  { int arr[T(__is_final(PotentiallySealed<int>))]; }
   { int arr[T(__is_final(FinalClass))]; }
   { int arr[T(__is_final(PotentiallyFinal<float*>))]; }
   { int arr[T(__is_final(PotentiallyFinal<int>))]; }
 
   { int arr[F(__is_final(int))]; }
   { int arr[F(__is_final(Union))]; }
   { int arr[F(__is_final(Int))]; }
   { int arr[F(__is_final(IntAr))]; }
   { int arr[F(__is_final(UnionAr))]; }
   { int arr[F(__is_final(Derives))]; }
   { int arr[F(__is_final(ClassType))]; }
   { int arr[F(__is_final(cvoid))]; }
   { int arr[F(__is_final(IntArNB))]; }
   { int arr[F(__is_final(HasAnonymousUnion))]; }
-  { int arr[F(__is_final(PotentiallyFinal<float>))]; }
-  { int arr[F(__is_final(PotentiallySealed<float>))]; }
 }
 
-void is_sealed()
-{
-  { int arr[T(__is_sealed(SealedClass))]; }
-  { int arr[T(__is_sealed(PotentiallySealed<float*>))]; }
-  { int arr[T(__is_sealed(PotentiallySealed<int>))]; }
-  { int arr[T(__is_sealed(FinalClass))]; }
-  { int arr[T(__is_sealed(PotentiallyFinal<float*>))]; }
-  { int arr[T(__is_sealed(PotentiallyFinal<int>))]; }
-
-  { int arr[F(__is_sealed(int))]; }
-  { int arr[F(__is_sealed(Union))]; }
-  { int arr[F(__is_sealed(Int))]; }
-  { int arr[F(__is_sealed(IntAr))]; }
-  { int arr[F(__is_sealed(UnionAr))]; }
-  { int arr[F(__is_sealed(Derives))]; }
-  { int arr[F(__is_sealed(ClassType))]; }
-  { int arr[F(__is_sealed(cvoid))]; }
-  { int arr[F(__is_sealed(IntArNB))]; }
-  { int arr[F(__is_sealed(HasAnonymousUnion))]; }
-  { int arr[F(__is_sealed(PotentiallyFinal<float>))]; }
-  { int arr[F(__is_sealed(PotentiallySealed<float>))]; }
-}
 
 typedef HasVirt Polymorph;
 struct InheritPolymorph : Polymorph {};
 
 void is_polymorphic()
 {
   { int arr[T(__is_polymorphic(Polymorph))]; }
   { int arr[T(__is_polymorphic(InheritPolymorph))]; }