chore: Clean up the type_traits tests

Author: robertoraggi

tests/unit_tests/parser/type_traits.001.cc

@@ -1,46 +1,43 @@
 // RUN: %cxx -verify -fsyntax-only %s -o -
 
-static_assert(__is_void(int));  // expected-error{{static_assert failed}}
+static_assert(__is_void(int) == false);
+static_assert(__is_void(void) == true);
+static_assert(__is_void(void*) == false);
+static_assert(__is_void(const void) == true);
+static_assert(__is_void(volatile void) == true);
+static_assert(__is_void(const volatile void) == true);
 
-static_assert(__is_void(void));
+static_assert(__is_same(decltype(__is_void(void)), bool) == true);
 
-static_assert(__is_void(void*));  // expected-error{{static_assert failed}}
+static_assert(__is_same(decltype(__is_void(void)), int) == false);
 
-static_assert(__is_same(decltype(__is_void(void)), bool));
-
-static_assert(__is_same(decltype(__is_void(void)),
-                        int));  // expected-error@-1{{static_assert failed}}
-
-static_assert(__is_pointer(void*));
+static_assert(__is_pointer(void*) == true);
 
 int* p;
 
-static_assert(__is_pointer(decltype(p)));
+static_assert(__is_pointer(decltype(p)) == true);
 
-static_assert(__is_pointer(int));  // expected-error{{static_assert failed}}
+static_assert(__is_pointer(int) == false);
 
 void foo() {}
 
-static_assert(
-    __is_pointer(decltype(foo)));  // expected-error{{static_assert failed}}
+static_assert(__is_pointer(decltype(foo)) == false);
 
 // __is_const
 
 const int v = 0;
 
-static_assert(__is_const(decltype(v)));
+static_assert(__is_const(decltype(v)) == true);
 
-volatile int* cv = nullptr;
+const int* cv = nullptr;
 
-static_assert(
-    __is_const(decltype(cv)));  // expected-error{{static_assert failed}}
+static_assert(__is_const(decltype(cv)) == false);
 
 int* const cv2 = nullptr;
 
-static_assert(__is_const(decltype(cv2)));
+static_assert(__is_const(decltype(cv2)) == true);
 
-static_assert(
-    __is_const(decltype(0)));  // expected-error{{static_assert failed}}
+static_assert(__is_const(decltype(0)) == false);
 
 // __is_volatile
 
@@ -56,67 +53,54 @@ static_assert(__is_volatile(decltype(pv)));
 
 // __is_null_pointer
 
-static_assert(__is_null_pointer(decltype(nullptr)));
+static_assert(__is_null_pointer(decltype(nullptr)) == true);
 
 void* ptr = nullptr;
 
-static_assert(__is_null_pointer(
-    decltype(ptr)));  // expected-error@-1{{static_assert failed}}
+static_assert(__is_null_pointer(decltype(ptr)) == false);
 
 using nullptr_t = decltype(nullptr);
 
-static_assert(__is_null_pointer(nullptr_t));
+static_assert(__is_null_pointer(nullptr_t) == true);
 
 // __is_signed
 
-static_assert(__is_signed(char));
-static_assert(__is_signed(short));
-static_assert(__is_signed(int));
-static_assert(__is_signed(long));
-static_assert(__is_signed(long long));
-
-static_assert(
-    __is_signed(unsigned char));  // expected-error{{static_assert failed}}
-
-static_assert(
-    __is_signed(unsigned short));  // expected-error{{static_assert failed}}
-
-static_assert(
-    __is_signed(unsigned int));  // expected-error{{static_assert failed}}
+static_assert(__is_signed(char) == true);
+static_assert(__is_signed(short) == true);
+static_assert(__is_signed(int) == true);
+static_assert(__is_signed(long) == true);
+static_assert(__is_signed(long long) == true);
 
-static_assert(
-    __is_signed(unsigned long));  // expected-error{{static_assert failed}}
-
-static_assert(
-    __is_signed(unsigned long long));  // expected-error{{static_assert failed}}
+static_assert(__is_signed(unsigned char) == false);
+static_assert(__is_signed(unsigned short) == false);
+static_assert(__is_signed(unsigned int) == false);
+static_assert(__is_signed(unsigned long) == false);
+static_assert(__is_signed(unsigned long long) == false);
 
 // __is_unsigned
 
-static_assert(__is_unsigned(unsigned char));
-static_assert(__is_unsigned(unsigned short));
-static_assert(__is_unsigned(unsigned int));
-static_assert(__is_unsigned(unsigned long));
-static_assert(__is_unsigned(unsigned long long));
-
-static_assert(__is_unsigned(char));   // expected-error{{static_assert failed}}
-static_assert(__is_unsigned(short));  // expected-error{{static_assert failed}}
-static_assert(__is_unsigned(int));    // expected-error{{static_assert failed}}
-static_assert(__is_unsigned(long));   // expected-error{{static_assert failed}}
+static_assert(__is_unsigned(unsigned char) == true);
+static_assert(__is_unsigned(unsigned short) == true);
+static_assert(__is_unsigned(unsigned int) == true);
+static_assert(__is_unsigned(unsigned long) == true);
+static_assert(__is_unsigned(unsigned long long) == true);
 
-static_assert(
-    __is_unsigned(long long));  // expected-error{{static_assert failed}}
+static_assert(__is_unsigned(char) == false);
+static_assert(__is_unsigned(short) == false);
+static_assert(__is_unsigned(int) == false);
+static_assert(__is_unsigned(long) == false);
+static_assert(__is_unsigned(long long) == false);
 
 // __is_enum and __is_scoped_enum
 
 enum ee {};
-
-static_assert(__is_enum(ee));
-
 enum class sc {};
 
-static_assert(__is_enum(sc));
+static_assert(__is_enum(ee) == true);
+static_assert(__is_enum(sc) == true);
 
-static_assert(__is_scoped_enum(sc));
+static_assert(__is_scoped_enum(sc) == true);
+static_assert(__is_scoped_enum(ee) == false);
 
 // __is_class and __is_union