[clang] 14e64cb - [clang] makes `__is_destructible` KEYALL instead of KEYMS
Christopher Di Bella via cfe-commits
cfe-commits at lists.llvm.org
Mon Oct 10 17:39:15 PDT 2022
Author: Christopher Di Bella
Date: 2022-10-11T00:13:58Z
New Revision: 14e64cb8d594c16c722da83d3e8af9fc0d013c4e
URL: https://github.com/llvm/llvm-project/commit/14e64cb8d594c16c722da83d3e8af9fc0d013c4e
DIFF: https://github.com/llvm/llvm-project/commit/14e64cb8d594c16c722da83d3e8af9fc0d013c4e.diff
LOG: [clang] makes `__is_destructible` KEYALL instead of KEYMS
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.
Differential Revision: https://reviews.llvm.org/D135339
Added:
clang/test/SemaCXX/type-traits-ms-extensions.cpp
Modified:
clang/docs/LanguageExtensions.rst
clang/include/clang/Basic/TokenKinds.def
clang/test/SemaCXX/type-traits.cpp
Removed:
################################################################################
diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst
index 162bcdd9fba7..b449809c88d5 100644
--- a/clang/docs/LanguageExtensions.rst
+++ b/clang/docs/LanguageExtensions.rst
@@ -1404,8 +1404,7 @@ The following type trait primitives are supported by Clang. Those traits marked
* ``__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)
@@ -1427,7 +1426,6 @@ The following type trait primitives are supported by Clang. Those traits marked
* ``__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
diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def
index 4e89752051bd..1127dc88c312 100644
--- a/clang/include/clang/Basic/TokenKinds.def
+++ b/clang/include/clang/Basic/TokenKinds.def
@@ -466,9 +466,9 @@ 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)
diff --git a/clang/test/SemaCXX/type-traits-ms-extensions.cpp b/clang/test/SemaCXX/type-traits-ms-extensions.cpp
new file mode 100644
index 000000000000..2f4e81498090
--- /dev/null
+++ b/clang/test/SemaCXX/type-traits-ms-extensions.cpp
@@ -0,0 +1,92 @@
+// 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 at -1{{}}
+}
+#endif
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index 35e21ee7688b..4369ed0c4672 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -1,6 +1,6 @@
-// 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
@@ -414,23 +414,12 @@ 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>))]; }
@@ -445,32 +434,8 @@ void is_final()
{ 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 {};
More information about the cfe-commits
mailing list