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 {{address expression must be an lvalue}}
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.
75template <int *PI, void (*PF)(), int A::*PM, void (A::*PMF)()>
76struct T {};
77
78typedef T<nullptr, nullptr, nullptr, nullptr> NT;
79
80namespace test1 {
81template<typename T, typename U> struct is_same {
82  static const bool value = false;
83};
84
85template<typename T> struct is_same<T, T> {
86  static const bool value = true;
87};
88
89void *g(void*);
90bool g(bool);
91
92// Test that we prefer g(void*) over g(bool).
93static_assert(is_same<decltype(g(nullptr)), void*>::value, "");
94}
95
96namespace 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
105namespace 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
114static_assert(__is_scalar(nullptr_t), "");
115static_assert(__is_pod(nullptr_t), "");
116static_assert(sizeof(nullptr_t) == sizeof(void*), "");
117
118static_assert(!(nullptr < nullptr), "");
119static_assert(!(nullptr > nullptr), "");
120static_assert(  nullptr <= nullptr, "");
121static_assert(  nullptr >= nullptr, "");
122static_assert(  nullptr == nullptr, "");
123static_assert(!(nullptr != nullptr), "");
124
125static_assert(!(0 < nullptr), "");
126static_assert(!(0 > nullptr), "");
127static_assert(  0 <= nullptr, "");
128static_assert(  0 >= nullptr, "");
129static_assert(  0 == nullptr, "");
130static_assert(!(0 != nullptr), "");
131
132static_assert(!(nullptr < 0), "");
133static_assert(!(nullptr > 0), "");
134static_assert(  nullptr <= 0, "");
135static_assert(  nullptr >= 0, "");
136static_assert(  nullptr == 0, "");
137static_assert(!(nullptr != 0), "");
138
139namespace 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
161namespace 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
178namespace 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.
182struct S { int n; };
183constexpr int null() { return 0; }
184void *p = S().n; // expected-error {{cannot initialize}}
185void *q = null(); // expected-error {{cannot initialize}}
186
187}
188