Fix __is_pointer builtin type trait to work with Objective-C pointer types.

[zoecarver]

Summary

5ade17e broke __is_pointer for Objective-C pointer types. This patch fixes the builtin and re-applies the change to type_traits.

[ldionne]

Thanks for looking into this!

clang/test/SemaObjC/type-traits-is-pointer.mm

10 ↗

(On Diff #255214)

You can just use static_assert directly here.

libcxx/include/type_traits

901

Doesn't __has_keyword return a number that can be compared against? #if __has_keyword(__is_pointer) > some-number would be better if feasible, because it would handle Clang, AppleClang and any other potential derivative.

[zoecarver]

@ldionne of course!

libcxx/include/type_traits

901

I don't think __has_keyword returns a comparable number. Libc++ defines __has_keyword using __is_identifier [1] and, it seems like all the feature checking macros from clang (including __is_identifier) have bool return types [2]. I can add an AppleClang check too if you want.

[1]:

#define __has_keyword(__x) !(__is_identifier(__x))

[2]: https://clang.llvm.org/docs/LanguageExtensions.html#feature-checking-macros

[zoecarver]

Fix based on review:

• Use static_assert directly in the test
• Update run command to work on non-objc platforms (e.g. linux)

[zoecarver]

Diff from master not last commit.

[ldionne]

libcxx/include/type_traits

901

Ah, you're right. There's no version of AppleClang to put here right now, so I'd say status quo is OK. I can add one later.

[ldionne]

clang/test/SemaObjCXX/type-traits-is-pointer.mm

2

Why do you run this through -verify? Can't you just drop that and the // expected-no-diagnostics bit too?

[ldionne]

clang/test/SemaObjCXX/type-traits-is-pointer.mm

2

Actually, never mind this. Someone pointed to me offline that using clang-verify has the benefit that no other diagnostics are going to be emitted, which is true. This is fine by me.

[zoecarver]

clang/test/SemaObjCXX/type-traits-is-pointer.mm

2

Great, thanks for the review. Most of these tests seem to use -verify so that's what I did.

libcxx/include/type_traits

901

Want me to add a TODO for you?

[ldionne]

libcxx/include/type_traits

901

Sure! Thanks!

clang/lib/Sema/SemaExprCXX.cpp

case UTT_IsVoid:
     return T->isVoidType();
   case UTT_IsIntegral:
     return T->isIntegralType(C);
   case UTT_IsFloatingPoint:
     return T->isFloatingType();
   case UTT_IsArray:
     return T->isArrayType();
   case UTT_IsPointer:
-    return T->isPointerType();
+    return T->isAnyPointerType();
   case UTT_IsLvalueReference:
     return T->isLValueReferenceType();
   case UTT_IsRvalueReference:
     return T->isRValueReferenceType();
   case UTT_IsMemberFunctionPointer:
     return T->isMemberFunctionPointerType();
   case UTT_IsMemberObjectPointer:
     return T->isMemberDataPointerType();

clang/test/SemaObjCXX/type-traits-is-pointer.mm

+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify %s
+// expected-no-diagnostics
+
+template <typename T>
+void test_is_pointer() {
+    static_assert(__is_pointer(T), "");
+
+    static_assert(__is_pointer(T __weak), "");
+    static_assert(__is_pointer(T __strong), "");
+    static_assert(__is_pointer(T __autoreleasing), "");
+    static_assert(__is_pointer(T __unsafe_unretained), "");
+
+    static_assert(__is_pointer(T __weak const), "");
+    static_assert(__is_pointer(T __strong const), "");
+    static_assert(__is_pointer(T __autoreleasing const), "");
+    static_assert(__is_pointer(T __unsafe_unretained const), "");
+
+    static_assert(__is_pointer(T __weak volatile), "");
+    static_assert(__is_pointer(T __strong volatile), "");
+    static_assert(__is_pointer(T __autoreleasing volatile), "");
+    static_assert(__is_pointer(T __unsafe_unretained volatile), "");
+
+    static_assert(__is_pointer(T __weak const volatile), "");
+    static_assert(__is_pointer(T __strong const volatile), "");
+    static_assert(__is_pointer(T __autoreleasing const volatile), "");
+    static_assert(__is_pointer(T __unsafe_unretained const volatile), "");
+}
+
+@class Foo;
+
+int main(int, char**) {
+    test_is_pointer<id>();
+    test_is_pointer<id const>();
+    test_is_pointer<id volatile>();
+    test_is_pointer<id const volatile>();
+
+    test_is_pointer<Foo*>();
+    test_is_pointer<Foo const*>();
+    test_is_pointer<Foo volatile*>();
+    test_is_pointer<Foo const volatile*>();
+
+    test_is_pointer<void*>();
+    test_is_pointer<void const*>();
+    test_is_pointer<void volatile*>();
+    test_is_pointer<void const volatile*>();
+
+    return 0;
+}

libcxx/include/type_traits

 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v
     = is_array<_Tp>::value;
 #endif
 
 #endif // __has_keyword(__is_array)
 
 // is_pointer
 
+// In clang 10.0.0 and earlier __is_pointer didn't work with Objective-C types.
+#if __has_keyword(__is_pointer) && _LIBCPP_CLANG_VER > 1000
+
+template<class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
+
+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v = __is_pointer(_Tp);
+#endif
+
+#else // __has_keyword(__is_pointer)
+
 template <class _Tp> struct __libcpp_is_pointer       : public false_type {};
 template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
 
 template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
 #if defined(_LIBCPP_HAS_OBJC_ARC)
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
 #endif
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
     : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<typename remove_cv<_Tp>::type>::type> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v
     = is_pointer<_Tp>::value;
 #endif
 
+#endif // __has_keyword(__is_pointer)
+
 // is_reference
 
 #if __has_keyword(__is_lvalue_reference) && \
     __has_keyword(__is_rvalue_reference) && \
     __has_keyword(__is_reference)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };