Richard Smith | 762bb9d | 2011-10-13 22:29:44 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding %s |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 2 | #include <stdint.h> |
| 3 | |
Anders Carlsson | c8df0b6 | 2010-11-05 00:12:09 +0000 | [diff] [blame] | 4 | typedef decltype(nullptr) nullptr_t; |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 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. |
Eli Friedman | cfdc81a | 2009-12-19 08:11:05 +0000 | [diff] [blame] | 31 | uintptr_t i = nullptr; // expected-error {{cannot initialize}} |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 32 | |
| 33 | // Operators |
| 34 | (void)(null == nullptr); |
| 35 | (void)(null <= nullptr); |
Richard Smith | 50d61c8 | 2012-08-08 06:13:49 +0000 | [diff] [blame] | 36 | (void)(null == 0); |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 37 | (void)(null == (void*)0); |
| 38 | (void)((void*)0 == nullptr); |
Richard Smith | 50d61c8 | 2012-08-08 06:13:49 +0000 | [diff] [blame] | 39 | (void)(null <= 0); |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 40 | (void)(null <= (void*)0); |
| 41 | (void)((void*)0 <= nullptr); |
Anders Carlsson | 0c8209e | 2010-11-04 03:17:43 +0000 | [diff] [blame] | 42 | (void)(0 == nullptr); |
| 43 | (void)(nullptr == 0); |
| 44 | (void)(nullptr <= 0); |
| 45 | (void)(0 <= nullptr); |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 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}} |
Richard Smith | 50d61c8 | 2012-08-08 06:13:49 +0000 | [diff] [blame] | 49 | (void)(0 ? nullptr : 0); |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 50 | (void)(0 ? nullptr : (void*)0); |
Chandler Carruth | 82214a8 | 2011-02-18 23:54:50 +0000 | [diff] [blame] | 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}} |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 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 |
Richard Smith | 3fa3fea | 2013-02-02 02:14:45 +0000 | [diff] [blame] | 60 | (void)&nullptr; // expected-error {{cannot take the address of an rvalue of type 'nullptr_t'}} |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 61 | nullptr_t *pn = &null; |
| 62 | |
| 63 | // You can reinterpret_cast nullptr to an integer. |
| 64 | (void)reinterpret_cast<uintptr_t>(nullptr); |
Douglas Gregor | 84ee2ee | 2011-05-21 23:15:46 +0000 | [diff] [blame] | 65 | (void)reinterpret_cast<uintptr_t>(*pn); |
| 66 | |
| 67 | int *ip = *pn; |
| 68 | if (*pn) { } |
Sebastian Redl | 6e8ed16 | 2009-05-10 18:38:11 +0000 | [diff] [blame] | 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; |
Anders Carlsson | c8df0b6 | 2010-11-05 00:12:09 +0000 | [diff] [blame] | 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 | } |
Anders Carlsson | 343e6ff | 2010-11-05 15:21:33 +0000 | [diff] [blame] | 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 | } |
Anders Carlsson | 6242599 | 2010-11-06 14:58:53 +0000 | [diff] [blame] | 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 | } |
Douglas Gregor | 84ee2ee | 2011-05-21 23:15:46 +0000 | [diff] [blame] | 113 | |
Dmitri Gribenko | d5f55dc | 2012-02-15 13:30:53 +0000 | [diff] [blame] | 114 | static_assert(__is_scalar(nullptr_t), ""); |
| 115 | static_assert(__is_pod(nullptr_t), ""); |
| 116 | static_assert(sizeof(nullptr_t) == sizeof(void*), ""); |
Douglas Gregor | 84ee2ee | 2011-05-21 23:15:46 +0000 | [diff] [blame] | 117 | |
Dmitri Gribenko | d5f55dc | 2012-02-15 13:30:53 +0000 | [diff] [blame] | 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), ""); |
Richard Smith | 26f2cac | 2012-02-14 22:35:28 +0000 | [diff] [blame] | 124 | |
Dmitri Gribenko | d5f55dc | 2012-02-15 13:30:53 +0000 | [diff] [blame] | 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), ""); |
Richard Smith | 26f2cac | 2012-02-14 22:35:28 +0000 | [diff] [blame] | 131 | |
Dmitri Gribenko | d5f55dc | 2012-02-15 13:30:53 +0000 | [diff] [blame] | 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), ""); |
Douglas Gregor | 84ee2ee | 2011-05-21 23:15:46 +0000 | [diff] [blame] | 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 | } |
Richard Smith | 70488e2 | 2012-02-14 21:38:30 +0000 | [diff] [blame] | 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 | } |