1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding %s 2 #include <stdint.h> 3 4 typedef decltype(nullptr) nullptr_t; 5 6 struct A {}; 7 8 int o1(char*); 9 void o1(uintptr_t); 10 void o2(char*); // expected-note {{candidate}} 11 void o2(int A::*); // expected-note {{candidate}} 12 13 nullptr_t f(nullptr_t null) 14 { 15 // Implicit conversions. 16 null = nullptr; 17 void *p = nullptr; 18 p = null; 19 int *pi = nullptr; 20 pi = null; 21 null = 0; 22 int A::*pm = nullptr; 23 pm = null; 24 void (*pf)() = nullptr; 25 pf = null; 26 void (A::*pmf)() = nullptr; 27 pmf = null; 28 bool b = nullptr; 29 30 // Can't convert nullptr to integral implicitly. 31 uintptr_t i = nullptr; // expected-error {{cannot initialize}} 32 33 // Operators 34 (void)(null == nullptr); 35 (void)(null <= nullptr); 36 (void)(null == 0); 37 (void)(null == (void*)0); 38 (void)((void*)0 == nullptr); 39 (void)(null <= 0); 40 (void)(null <= (void*)0); 41 (void)((void*)0 <= nullptr); 42 (void)(0 == nullptr); 43 (void)(nullptr == 0); 44 (void)(nullptr <= 0); 45 (void)(0 <= nullptr); 46 (void)(1 > nullptr); // expected-error {{invalid operands to binary expression}} 47 (void)(1 != nullptr); // expected-error {{invalid operands to binary expression}} 48 (void)(1 + nullptr); // expected-error {{invalid operands to binary expression}} 49 (void)(0 ? nullptr : 0); 50 (void)(0 ? nullptr : (void*)0); 51 (void)(0 ? nullptr : A()); // expected-error {{non-pointer operand type 'A' incompatible with nullptr}} 52 (void)(0 ? A() : nullptr); // expected-error {{non-pointer operand type 'A' incompatible with nullptr}} 53 54 // Overloading 55 int t = o1(nullptr); 56 t = o1(null); 57 o2(nullptr); // expected-error {{ambiguous}} 58 59 // nullptr is an rvalue, null is an lvalue 60 (void)&nullptr; // expected-error {{cannot take the address of an rvalue of type 'nullptr_t'}} 61 nullptr_t *pn = &null; 62 63 // You can reinterpret_cast nullptr to an integer. 64 (void)reinterpret_cast<uintptr_t>(nullptr); 65 (void)reinterpret_cast<uintptr_t>(*pn); 66 67 int *ip = *pn; 68 if (*pn) { } 69 70 // You can throw nullptr. 71 throw nullptr; 72 } 73 74 // Template arguments can be nullptr. 75 template <int *PI, void (*PF)(), int A::*PM, void (A::*PMF)()> 76 struct T {}; 77 78 typedef T<nullptr, nullptr, nullptr, nullptr> NT; 79 80 namespace test1 { 81 template<typename T, typename U> struct is_same { 82 static const bool value = false; 83 }; 84 85 template<typename T> struct is_same<T, T> { 86 static const bool value = true; 87 }; 88 89 void *g(void*); 90 bool g(bool); 91 92 // Test that we prefer g(void*) over g(bool). 93 static_assert(is_same<decltype(g(nullptr)), void*>::value, ""); 94 } 95 96 namespace test2 { 97 void f(int, ...) __attribute__((sentinel)); 98 99 void g() { 100 // nullptr can be used as the sentinel value. 101 f(10, nullptr); 102 } 103 } 104 105 namespace test3 { 106 void f(const char*, ...) __attribute__((format(printf, 1, 2))); 107 108 void g() { 109 // Don't warn when using nullptr with %p. 110 f("%p", nullptr); 111 } 112 } 113 114 static_assert(__is_scalar(nullptr_t), ""); 115 static_assert(__is_pod(nullptr_t), ""); 116 static_assert(sizeof(nullptr_t) == sizeof(void*), ""); 117 118 static_assert(!(nullptr < nullptr), ""); 119 static_assert(!(nullptr > nullptr), ""); 120 static_assert( nullptr <= nullptr, ""); 121 static_assert( nullptr >= nullptr, ""); 122 static_assert( nullptr == nullptr, ""); 123 static_assert(!(nullptr != nullptr), ""); 124 125 static_assert(!(0 < nullptr), ""); 126 static_assert(!(0 > nullptr), ""); 127 static_assert( 0 <= nullptr, ""); 128 static_assert( 0 >= nullptr, ""); 129 static_assert( 0 == nullptr, ""); 130 static_assert(!(0 != nullptr), ""); 131 132 static_assert(!(nullptr < 0), ""); 133 static_assert(!(nullptr > 0), ""); 134 static_assert( nullptr <= 0, ""); 135 static_assert( nullptr >= 0, ""); 136 static_assert( nullptr == 0, ""); 137 static_assert(!(nullptr != 0), ""); 138 139 namespace overloading { 140 int &f1(int*); 141 float &f1(bool); 142 143 void test_f1() { 144 int &ir = (f1)(nullptr); 145 } 146 147 struct ConvertsToNullPtr { 148 operator nullptr_t() const; 149 }; 150 151 void test_conversion(ConvertsToNullPtr ctn) { 152 (void)(ctn == ctn); 153 (void)(ctn != ctn); 154 (void)(ctn <= ctn); 155 (void)(ctn >= ctn); 156 (void)(ctn < ctn); 157 (void)(ctn > ctn); 158 } 159 } 160 161 namespace templates { 162 template<typename T, nullptr_t Value> 163 struct X { 164 X() { ptr = Value; } 165 166 T *ptr; 167 }; 168 169 X<int, nullptr> x; 170 171 172 template<int (*fp)(int), int* p, int A::* pmd, int (A::*pmf)(int)> 173 struct X2 {}; 174 175 X2<nullptr, nullptr, nullptr, nullptr> x2; 176 } 177 178 namespace null_pointer_constant { 179 180 // Pending implementation of core issue 903, ensure we don't allow any of the 181 // C++11 constant evaluation semantics in null pointer constants. 182 struct S { int n; }; 183 constexpr int null() { return 0; } 184 void *p = S().n; // expected-error {{cannot initialize}} 185 void *q = null(); // expected-error {{cannot initialize}} 186 187 } 188
