xref: /llvm-project/clang/test/C/C23/n3042.c (revision 50c81128de8616117118564eff22cf508cba7848)

// RUN: %clang_cc1 -verify -ffreestanding -Wno-unused -std=c2x %s

/* WG14 N3042: full
 * Introduce the nullptr constant
 */

#include <stddef.h>

// FIXME: The paper calls for a feature testing macro to be added to stddef.h
// which we do not implement. This should be addressed after WG14 has processed
// national body comments for C2x as we've asked for the feature test macros to
// be removed.
#ifndef __STDC_VERSION_STDDEF_H__
#error "no version macro for stddef.h"
#endif
// expected-error@-2 {{"no version macro for stddef.h"}}

void questionable_behaviors() {
  nullptr_t val;

  // This code is intended to be rejected by C and is accepted by C++. We filed
  // an NB comment asking for this to be changed, but WG14 declined.
  (void)(1 ? val : 0);     // expected-error {{non-pointer operand type 'int' incompatible with nullptr}}
  (void)(1 ? nullptr : 0); // expected-error {{non-pointer operand type 'int' incompatible with nullptr}}

  // This code is intended to be accepted by C and is rejected by C++. We filed
  // an NB comment asking for this to be changed, but WG14 declined.
  _Bool another = val;    // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  another = val;          // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  _Bool again = nullptr;  // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  again = nullptr;        // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
}

void test() {
  // Can we declare the type?
  nullptr_t null_val;

  // Can we use the keyword?
  int *typed_ptr = nullptr;
  typed_ptr = nullptr;

  // Can we use the keyword with the type?
  null_val = nullptr;
  // Even initialize with it?
  nullptr_t ignore = nullptr;

  // Can we assign an object of the type to another object of the same type?
  null_val = null_val;

  // Can we assign nullptr_t objects to pointer objects?
  typed_ptr = null_val;

  // Can we take the address of an object of type nullptr_t?
  &null_val;

  // How about the null pointer named constant?
  &nullptr; // expected-error {{cannot take the address of an rvalue of type 'nullptr_t'}}

  // Assignment from a null pointer constant to a nullptr_t is valid.
  null_val = 0;
  null_val = (void *)0;

  // Assignment from a nullptr_t to a pointer is also valid.
  typed_ptr = null_val;
  void *other_ptr = null_val;

  // Can it be used in all the places a scalar can be used?
  if (null_val) {}     // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  if (!null_val) {}    // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  for (;null_val;) {}  // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  while (nullptr) {}   // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  null_val && nullptr; // expected-warning {{implicit conversion of nullptr constant to 'bool'}} \
                          expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  nullptr || null_val; // expected-warning {{implicit conversion of nullptr constant to 'bool'}} \
                          expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  null_val ? 0 : 1;    // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  sizeof(null_val);
  alignas(nullptr_t) int aligned;

  // Cast expressions have special handling for nullptr_t despite allowing
  // casts of scalar types.
  (nullptr_t)12;        // expected-error {{cannot cast an object of type 'int' to 'nullptr_t'}}
  (float)null_val;      // expected-error {{cannot cast an object of type 'nullptr_t' to 'float'}}
  (float)nullptr;       // expected-error {{cannot cast an object of type 'nullptr_t' to 'float'}}
  (nullptr_t)0;         // expected-error {{cannot cast an object of type 'int' to 'nullptr_t'}}
  (nullptr_t)(void *)0; // expected-error {{cannot cast an object of type 'void *' to 'nullptr_t'}}
  (nullptr_t)(int *)12; // expected-error {{cannot cast an object of type 'int *' to 'nullptr_t'}}

  (void)null_val;     // ok
  (void)nullptr;      // ok
  (bool)null_val;     // ok
  (bool)nullptr;      // ok
  (int *)null_val;    // ok
  (int *)nullptr;     // ok
  (nullptr_t)nullptr; // ok

  // Can it be converted to bool with the result false (this relies on Clang
  // accepting additional kinds of constant expressions where an ICE is
  // required)?
  static_assert(!nullptr);  // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  static_assert(!null_val); // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  static_assert(nullptr);   // expected-error {{static assertion failed due to requirement 'nullptr'}} \
                               expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  static_assert(null_val);  // expected-error {{static assertion failed due to requirement 'null_val'}} \
                               expected-warning {{implicit conversion of nullptr constant to 'bool'}}

  // Do equality operators work as expected with it?
  static_assert(nullptr == nullptr);
  static_assert(null_val == null_val);
  static_assert(nullptr != (int*)1);
  static_assert(null_val != (int*)1);
  static_assert(nullptr == null_val);
  static_assert(nullptr == 0);
  static_assert(null_val == (void *)0);

  // None of the relational operators should succeed.
  (void)(null_val <= 0);            // expected-error {{invalid operands to binary expression ('nullptr_t' and 'int')}}
  (void)(null_val >= (void *)0);    // expected-error {{invalid operands to binary expression ('nullptr_t' and 'void *')}}
  (void)(!(null_val < (void *)0));  // expected-error {{invalid operands to binary expression ('nullptr_t' and 'void *')}}
  (void)(!(null_val > 0));          // expected-error {{invalid operands to binary expression ('nullptr_t' and 'int')}}
  (void)(nullptr <= 0);             // expected-error {{invalid operands to binary expression ('nullptr_t' and 'int')}}
  (void)(nullptr >= (void *)0);     // expected-error {{invalid operands to binary expression ('nullptr_t' and 'void *')}}
  (void)(!(nullptr < (void *)0));   // expected-error {{invalid operands to binary expression ('nullptr_t' and 'void *')}}
  (void)(!(nullptr > 0));           // expected-error {{invalid operands to binary expression ('nullptr_t' and 'int')}}
  (void)(null_val <= null_val);     // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(null_val >= null_val);     // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(null_val < null_val));   // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(null_val > null_val));   // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(null_val <= nullptr);      // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(null_val >= nullptr);      // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(null_val < nullptr));    // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(null_val > nullptr));    // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(nullptr <= nullptr);       // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(nullptr >= nullptr);       // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(nullptr < nullptr));     // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}
  (void)(!(nullptr > nullptr));     // expected-error {{invalid operands to binary expression ('nullptr_t' and 'nullptr_t')}}

  // Do we pick the correct common type for conditional operators?
  _Generic(1 ? nullptr : nullptr, nullptr_t : 0);
  _Generic(1 ? null_val : null_val, nullptr_t : 0);
  _Generic(1 ? typed_ptr : null_val, typeof(typed_ptr) : 0);
  _Generic(1 ? null_val : typed_ptr, typeof(typed_ptr) : 0);
  _Generic(1 ? nullptr : typed_ptr, typeof(typed_ptr) : 0);
  _Generic(1 ? typed_ptr : nullptr, typeof(typed_ptr) : 0);

  // Same for GNU conditional operators?
  _Generic(nullptr ?: nullptr, nullptr_t : 0);            // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  _Generic(null_val ?: null_val, nullptr_t : 0);          // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  _Generic(typed_ptr ?: null_val, typeof(typed_ptr) : 0);
  _Generic(null_val ?: typed_ptr, typeof(typed_ptr) : 0); // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  _Generic(nullptr ?: typed_ptr, typeof(typed_ptr) : 0);  // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
  _Generic(typed_ptr ?: nullptr, typeof(typed_ptr) : 0);

  // Do we correctly issue type incompatibility diagnostics?
  int i = nullptr;   // expected-error {{initializing 'int' with an expression of incompatible type 'nullptr_t'}}
  float f = nullptr; // expected-error {{initializing 'float' with an expression of incompatible type 'nullptr_t'}}
  i = null_val;      // expected-error {{assigning to 'int' from incompatible type 'nullptr_t'}}
  f = null_val;      // expected-error {{assigning to 'float' from incompatible type 'nullptr_t'}}
  null_val = i;      // expected-error {{assigning to 'nullptr_t' from incompatible type 'int'}}
  null_val = f;      // expected-error {{assigning to 'nullptr_t' from incompatible type 'float'}}
}

// Can we use it as a function parameter?
void null_param(nullptr_t);

void other_test() {
  // Can we call the function properly?
  null_param(nullptr);

  // We can pass any kind of null pointer constant.
  null_param((void *)0);
  null_param(0);
}


void printf(const char*, ...) __attribute__((format(printf, 1, 2)));
void format_specifiers() {
  // Don't warn when using nullptr with %p.
  printf("%p", nullptr);
}

// Ensure that conversion from a null pointer constant to nullptr_t is
// valid in a constant expression.
static_assert((nullptr_t){} == 0);