forked from OSchip/llvm-project
86 lines
3.2 KiB
C++
86 lines
3.2 KiB
C++
// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -std=c++11 -verify %s
|
|
|
|
// If an expression of literal class type is used in a context where an integral
|
|
// constant expression is required, then that class type shall have a single
|
|
// non-explicit conversion function to an integral or unscoped enumeration type
|
|
namespace std_example {
|
|
|
|
struct A {
|
|
constexpr A(int i) : val(i) { }
|
|
constexpr operator int() const { return val; }
|
|
constexpr operator long() const { return 43; }
|
|
private:
|
|
int val;
|
|
};
|
|
template<int> struct X { };
|
|
constexpr A a = 42;
|
|
X<a> x; // ok, unique conversion to int
|
|
int ary[a]; // expected-error {{size of array has non-integer type 'const std_example::A'}}
|
|
|
|
}
|
|
|
|
struct OK {
|
|
constexpr OK() {}
|
|
constexpr operator int() const { return 8; }
|
|
} constexpr ok;
|
|
extern struct Incomplete incomplete; // expected-note 4{{forward decl}}
|
|
struct Explicit {
|
|
constexpr Explicit() {}
|
|
constexpr explicit operator int() const { return 4; } // expected-note 4{{here}}
|
|
} constexpr expl;
|
|
struct Ambiguous {
|
|
constexpr Ambiguous() {}
|
|
constexpr operator int() const { return 2; } // expected-note 4{{here}}
|
|
constexpr operator long() const { return 1; } // expected-note 4{{here}}
|
|
} constexpr ambig;
|
|
|
|
constexpr int test_ok = ok; // ok
|
|
constexpr int test_explicit(expl); // ok
|
|
constexpr int test_ambiguous = ambig; // ok
|
|
|
|
static_assert(test_ok == 8, "");
|
|
static_assert(test_explicit == 4, "");
|
|
static_assert(test_ambiguous == 2, "");
|
|
|
|
// [expr.new]p6: Every constant-expression in a noptr-new-declarator shall be
|
|
// an integral constant expression
|
|
auto new1 = new int[1][ok];
|
|
auto new2 = new int[1][incomplete]; // expected-error {{incomplete}}
|
|
auto new3 = new int[1][expl]; // expected-error {{explicit conversion}}
|
|
auto new4 = new int[1][ambig]; // expected-error {{ambiguous conversion}}
|
|
|
|
// [dcl.enum]p5: If the underlying type is not fixed [...] the initializing
|
|
// value [...] shall be an integral constant expression.
|
|
enum NotFixed {
|
|
enum1 = ok,
|
|
enum2 = incomplete, // expected-error {{incomplete}}
|
|
enum3 = expl, // expected-error {{explicit conversion}}
|
|
enum4 = ambig // expected-error {{ambiguous conversion}}
|
|
};
|
|
|
|
// [dcl.align]p2: When the alignment-specifier is of the form
|
|
// alignas(assignment-expression), the assignment-expression shall be an
|
|
// integral constant expression
|
|
alignas(ok) int alignas1;
|
|
alignas(incomplete) int alignas2; // expected-error {{incomplete}}
|
|
alignas(expl) int alignas3; // expected-error {{explicit conversion}}
|
|
alignas(ambig) int alignas4; // expected-error {{ambiguous conversion}}
|
|
|
|
// [dcl.array]p1: If the constant-expression is present, it shall be an integral
|
|
// constant expression
|
|
// FIXME: The VLA recovery results in us giving diagnostics which aren't great
|
|
// here.
|
|
int array1[ok];
|
|
int array2[incomplete]; // expected-error {{non-integer type}}
|
|
int array3[expl]; // expected-error {{non-integer type}}
|
|
int array4[ambig]; // expected-error {{non-integer type}}
|
|
|
|
// [class.bit]p1: The constasnt-expression shall be an integral constant
|
|
// expression
|
|
struct Bitfields {
|
|
int bitfield1 : ok;
|
|
int bitfield2 : incomplete; // expected-error {{incomplete}}
|
|
int bitfield3 : expl; // expected-error {{explicit conversion}}
|
|
int bitfield4 : ambig; // expected-error {{ambiguous conversion}}
|
|
};
|