1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding -Wno-null-conversion -Wno-tautological-compare %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
f(nullptr_t null)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; // expected-error {{cannot initialize}}
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); // expected-error {{invalid operands to binary expression}}
36 (void)(null == 0);
37 (void)(null == (void*)0);
38 (void)((void*)0 == nullptr);
39 (void)(null <= 0); // expected-error {{invalid operands to binary expression}}
40 (void)(null <= (void*)0); // expected-error {{invalid operands to binary expression}}
41 (void)((void*)0 <= nullptr); // expected-error {{invalid operands to binary expression}}
42 (void)(0 == nullptr);
43 (void)(nullptr == 0);
44 (void)(nullptr <= 0); // expected-error {{invalid operands to binary expression}}
45 (void)(0 <= nullptr); // expected-error {{invalid operands to binary expression}}
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 // You can't reinterpret_cast nullptr to any integer
68 (void)reinterpret_cast<char>(nullptr); // expected-error {{cast from pointer to smaller type 'char' loses information}}
69
70 int *ip = *pn;
71 if (*pn) { }
72
73 // You can throw nullptr.
74 throw nullptr;
75 }
76
77 // Template arguments can be nullptr.
78 template <int *PI, void (*PF)(), int A::*PM, void (A::*PMF)()>
79 struct T {};
80
81 typedef T<nullptr, nullptr, nullptr, nullptr> NT;
82
83 namespace test1 {
84 template<typename T, typename U> struct is_same {
85 static const bool value = false;
86 };
87
88 template<typename T> struct is_same<T, T> {
89 static const bool value = true;
90 };
91
92 void *g(void*);
93 bool g(bool);
94
95 // Test that we prefer g(void*) over g(bool).
96 static_assert(is_same<decltype(g(nullptr)), void*>::value, "");
97 }
98
99 namespace test2 {
100 void f(int, ...) __attribute__((sentinel));
101
g()102 void g() {
103 // nullptr can be used as the sentinel value.
104 f(10, nullptr);
105 }
106 }
107
108 namespace test3 {
109 void f(const char*, ...) __attribute__((format(printf, 1, 2)));
110
g()111 void g() {
112 // Don't warn when using nullptr with %p.
113 f("%p", nullptr);
114 }
115 }
116
117 static_assert(__is_scalar(nullptr_t), "");
118 static_assert(__is_pod(nullptr_t), "");
119 static_assert(sizeof(nullptr_t) == sizeof(void*), "");
120
121 static_assert(!(nullptr < nullptr), ""); // expected-error {{invalid operands to binary expression}}
122 static_assert(!(nullptr > nullptr), ""); // expected-error {{invalid operands to binary expression}}
123 static_assert( nullptr <= nullptr, ""); // expected-error {{invalid operands to binary expression}}
124 static_assert( nullptr >= nullptr, ""); // expected-error {{invalid operands to binary expression}}
125 static_assert( nullptr == nullptr, "");
126 static_assert(!(nullptr != nullptr), "");
127
128 static_assert(!(0 < nullptr), ""); // expected-error {{invalid operands to binary expression}}
129 static_assert(!(0 > nullptr), ""); // expected-error {{invalid operands to binary expression}}
130 static_assert( 0 <= nullptr, ""); // expected-error {{invalid operands to binary expression}}
131 static_assert( 0 >= nullptr, ""); // expected-error {{invalid operands to binary expression}}
132 static_assert( 0 == nullptr, "");
133 static_assert(!(0 != nullptr), "");
134
135 static_assert(!(nullptr < 0), ""); // expected-error {{invalid operands to binary expression}}
136 static_assert(!(nullptr > 0), ""); // expected-error {{invalid operands to binary expression}}
137 static_assert( nullptr <= 0, ""); // expected-error {{invalid operands to binary expression}}
138 static_assert( nullptr >= 0, ""); // expected-error {{invalid operands to binary expression}}
139 static_assert( nullptr == 0, "");
140 static_assert(!(nullptr != 0), "");
141
142 namespace overloading {
143 int &f1(int*);
144 float &f1(bool);
145
test_f1()146 void test_f1() {
147 int &ir = (f1)(nullptr);
148 }
149
150 struct ConvertsToNullPtr {
151 operator nullptr_t() const;
152 };
153
test_conversion(ConvertsToNullPtr ctn)154 void test_conversion(ConvertsToNullPtr ctn) {
155 (void)(ctn == ctn);
156 (void)(ctn != ctn);
157 (void)(ctn <= ctn); // expected-error {{invalid operands to binary expression}}
158 (void)(ctn >= ctn); // expected-error {{invalid operands to binary expression}}
159 (void)(ctn < ctn); // expected-error {{invalid operands to binary expression}}
160 (void)(ctn > ctn); // expected-error {{invalid operands to binary expression}}
161 }
162 }
163
164 namespace templates {
165 template<typename T, nullptr_t Value>
166 struct X {
Xtemplates::X167 X() { ptr = Value; }
168
169 T *ptr;
170 };
171
172 X<int, nullptr> x;
173
174
175 template<int (*fp)(int), int* p, int A::* pmd, int (A::*pmf)(int)>
176 struct X2 {};
177
178 X2<nullptr, nullptr, nullptr, nullptr> x2;
179 }
180
181 namespace null_pointer_constant {
182
183 // Pending implementation of core issue 903, ensure we don't allow any of the
184 // C++11 constant evaluation semantics in null pointer constants.
185 struct S { int n; };
null()186 constexpr int null() { return 0; }
187 void *p = S().n; // expected-error {{cannot initialize}}
188 void *q = null(); // expected-error {{cannot initialize}}
189
190 }
191