1// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding %s
2#include <stdint.h>
3
4typedef decltype(nullptr) nullptr_t;
5
6struct A {};
7
8int o1(char*);
9void o1(uintptr_t);
10void o2(char*); // expected-note {{candidate}}
11void o2(int A::*); // expected-note {{candidate}}
12
13nullptr_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  // 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.
78template <int *PI, void (*PF)(), int A::*PM, void (A::*PMF)()>
79struct T {};
80
81typedef T<nullptr, nullptr, nullptr, nullptr> NT;
82
83namespace test1 {
84template<typename T, typename U> struct is_same {
85  static const bool value = false;
86};
87
88template<typename T> struct is_same<T, T> {
89  static const bool value = true;
90};
91
92void *g(void*);
93bool g(bool);
94
95// Test that we prefer g(void*) over g(bool).
96static_assert(is_same<decltype(g(nullptr)), void*>::value, "");
97}
98
99namespace test2 {
100  void f(int, ...) __attribute__((sentinel));
101
102  void g() {
103    // nullptr can be used as the sentinel value.
104    f(10, nullptr);
105  }
106}
107
108namespace test3 {
109  void f(const char*, ...) __attribute__((format(printf, 1, 2)));
110
111  void g() {
112    // Don't warn when using nullptr with %p.
113    f("%p", nullptr);
114  }
115}
116
117static_assert(__is_scalar(nullptr_t), "");
118static_assert(__is_pod(nullptr_t), "");
119static_assert(sizeof(nullptr_t) == sizeof(void*), "");
120
121static_assert(!(nullptr < nullptr), "");
122static_assert(!(nullptr > nullptr), "");
123static_assert(  nullptr <= nullptr, "");
124static_assert(  nullptr >= nullptr, "");
125static_assert(  nullptr == nullptr, "");
126static_assert(!(nullptr != nullptr), "");
127
128static_assert(!(0 < nullptr), "");
129static_assert(!(0 > nullptr), "");
130static_assert(  0 <= nullptr, "");
131static_assert(  0 >= nullptr, "");
132static_assert(  0 == nullptr, "");
133static_assert(!(0 != nullptr), "");
134
135static_assert(!(nullptr < 0), "");
136static_assert(!(nullptr > 0), "");
137static_assert(  nullptr <= 0, "");
138static_assert(  nullptr >= 0, "");
139static_assert(  nullptr == 0, "");
140static_assert(!(nullptr != 0), "");
141
142namespace overloading {
143  int &f1(int*);
144  float &f1(bool);
145
146  void test_f1() {
147    int &ir = (f1)(nullptr);
148  }
149
150  struct ConvertsToNullPtr {
151    operator nullptr_t() const;
152  };
153
154  void test_conversion(ConvertsToNullPtr ctn) {
155    (void)(ctn == ctn);
156    (void)(ctn != ctn);
157    (void)(ctn <= ctn);
158    (void)(ctn >= ctn);
159    (void)(ctn < ctn);
160    (void)(ctn > ctn);
161  }
162}
163
164namespace templates {
165  template<typename T, nullptr_t Value>
166  struct X {
167    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
181namespace 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.
185struct S { int n; };
186constexpr int null() { return 0; }
187void *p = S().n; // expected-error {{cannot initialize}}
188void *q = null(); // expected-error {{cannot initialize}}
189
190}
191