// RUN: %clang_cc1 -std=c++2c -fsyntax-only -verify %s
struct S {
void f() = delete("deleted (1)"); // expected-note {{explicitly marked deleted}}
template <typename T>
T g() = delete("deleted (2)"); // expected-note {{explicitly deleted}}
};
template <typename T>
struct TS {
T f() = delete("deleted (3)"); // expected-note {{explicitly marked deleted}}
template <typename U>
T g(U) = delete("deleted (4)"); // expected-note {{explicitly deleted}}
};
void f() = delete("deleted (5)"); // expected-note {{explicitly deleted}}
template <typename T>
T g() = delete("deleted (6)"); // expected-note {{explicitly deleted}}
template <typename T, typename U>
struct TSp {
T f() = delete("deleted (7)"); // expected-note 2 {{explicitly marked deleted}}
};
template <typename T>
struct TSp<T, int> {
T f() = delete("deleted (8)"); // expected-note {{explicitly marked deleted}}
};
template <>
struct TSp<int, int> {
int f() = delete("deleted (9)"); // expected-note {{explicitly marked deleted}}
};
void u1() = delete(L"\xFFFFFFFF"); // expected-error {{an unevaluated string literal cannot have an encoding prefix}} \
// expected-error {{invalid escape sequence '\xFFFFFFFF' in an unevaluated string literal}}
void u2() = delete(u"\U000317FF"); // expected-error {{an unevaluated string literal cannot have an encoding prefix}}
void u3() = delete("Ω"); // expected-note {{explicitly deleted}}
void u4() = delete("\u1234"); // expected-note {{explicitly deleted}}
void u5() = delete("\x1ff" // expected-error {{hex escape sequence out of range}} \
// expected-error {{invalid escape sequence '\x1ff' in an unevaluated string literal}}
"0\x123" // expected-error {{invalid escape sequence '\x123' in an unevaluated string literal}}
"fx\xfffff" // expected-error {{invalid escape sequence '\xfffff' in an unevaluated string literal}}
"goop");
void u6() = delete("\'\"\?\\\a\b\f\n\r\t\v"); // expected-note {{explicitly deleted}}
void u7() = delete("\xFF"); // expected-error {{invalid escape sequence '\xFF' in an unevaluated string literal}}
void u8() = delete("\123"); // expected-error {{invalid escape sequence '\123' in an unevaluated string literal}}
void u9() = delete("\pOh no, a Pascal string!"); // expected-warning {{unknown escape sequence '\p'}} \
// expected-error {{invalid escape sequence '\p' in an unevaluated string literal}}
// expected-note@+1 {{explicitly deleted}}
void u10() = delete(R"(a
\tb
c
)");
void u11() = delete("\u0080\u0081\u0082\u0083\u0099\u009A\u009B\u009C\u009D\u009E\u009F"); // expected-note {{explicitly deleted}}
//! Contains RTL/LTR marks
void u12() = delete("\u200Eabc\u200Fdef\u200Fgh"); // expected-note {{explicitly deleted}}
//! Contains ZWJ/regional indicators
void u13() = delete("🏳️🌈 🏴 🇪🇺"); // expected-note {{explicitly deleted}}
void h() {
S{}.f(); // expected-error {{attempt to use a deleted function: deleted (1)}}
S{}.g<int>(); // expected-error {{call to deleted member function 'g': deleted (2)}}
TS<int>{}.f(); // expected-error {{attempt to use a deleted function: deleted (3)}}
TS<int>{}.g<int>(0); // expected-error {{call to deleted member function 'g': deleted (4)}}
f(); // expected-error {{call to deleted function 'f': deleted (5)}}
g<int>(); // expected-error {{call to deleted function 'g': deleted (6)}}
TSp<double, double>{}.f(); // expected-error {{attempt to use a deleted function: deleted (7)}}
TSp<int, double>{}.f(); // expected-error {{attempt to use a deleted function: deleted (7)}}
TSp<double, int>{}.f(); // expected-error {{attempt to use a deleted function: deleted (8)}}
TSp<int, int>{}.f(); // expected-error {{attempt to use a deleted function: deleted (9)}}
u3(); // expected-error {{call to deleted function 'u3': Ω}}
u4(); // expected-error {{call to deleted function 'u4': ሴ}}
u6(); // expected-error {{call to deleted function 'u6': '"?\<U+0007><U+0008>}}
u10(); // expected-error {{call to deleted function 'u10': a\n\tb\nc\n}}
u11(); // expected-error {{call to deleted function 'u11': <U+0080><U+0081><U+0082><U+0083><U+0099><U+009A><U+009B><U+009C><U+009D><U+009E><U+009F>}}
u12(); // expected-error {{call to deleted function 'u12': abcdefgh}}
u13(); // expected-error {{call to deleted function 'u13': 🏳️🌈 🏴 🇪🇺}}
}
struct C {
C() = delete("deleted (C, Constructor)"); // expected-note {{explicitly marked deleted}}
C(int) = delete("deleted (C, C(int))"); // expected-note {{explicitly marked deleted}}
C(const C&) = delete("deleted (C, Copy Constructor)"); // expected-note {{explicitly marked deleted}}
C(C&&) = delete("deleted (C, Move Constructor)"); // expected-note {{explicitly marked deleted}}
C& operator=(const C&) = delete("deleted (C, Copy Assignment)"); // expected-note 2 {{explicitly deleted}}
C& operator=(C&&) = delete("deleted (C, Move Assignment)"); // expected-note {{explicitly deleted}} expected-note {{not viable}}
~C() = delete("deleted (C, Destructor)"); // expected-note {{explicitly marked deleted}}
void* operator new(__SIZE_TYPE__) = delete("deleted (C, New)"); // expected-note {{explicitly deleted}}
void operator delete(void*) = delete("deleted (C, Delete)"); // expected-note {{explicitly marked deleted}}
};
template <typename T, typename U>
struct TC {
TC() = delete("deleted (TC, Constructor)"); // expected-note {{explicitly marked deleted}}
TC(int) = delete("deleted (TC, TC(int))"); // expected-note {{explicitly marked deleted}}
TC(const TC&) = delete("deleted (TC, Copy Constructor)"); // expected-note {{explicitly marked deleted}}
TC(TC&&) = delete("deleted (TC, Move Constructor)"); // expected-note {{explicitly marked deleted}}
TC& operator=(const TC&) = delete("deleted (TC, Copy Assignment)"); // expected-note 2 {{explicitly deleted}}
TC& operator=(TC&&) = delete("deleted (TC, Move Assignment)"); // expected-note {{explicitly deleted}} expected-note {{not viable}}
~TC() = delete("deleted (TC, Destructor)"); // expected-note {{explicitly marked deleted}}
void* operator new(__SIZE_TYPE__) = delete("deleted (TC, New)"); // expected-note {{explicitly deleted}}
void operator delete(void*) = delete("deleted (TC, Delete)"); // expected-note {{explicitly marked deleted}}
};
template <typename T>
struct TC<T, int> {
TC() = delete("deleted (TC<T, int>, Constructor)"); // expected-note {{explicitly marked deleted}}
TC(int) = delete("deleted (TC<T, int>, TC(int))"); // expected-note {{explicitly marked deleted}}
TC(const TC&) = delete("deleted (TC<T, int>, Copy Constructor)"); // expected-note {{explicitly marked deleted}}
TC(TC&&) = delete("deleted (TC<T, int>, Move Constructor)"); // expected-note {{explicitly marked deleted}}
TC& operator=(const TC&) = delete("deleted (TC<T, int>, Copy Assignment)"); // expected-note 2 {{explicitly deleted}}
TC& operator=(TC&&) = delete("deleted (TC<T, int>, Move Assignment)"); // expected-note {{explicitly deleted}} expected-note {{not viable}}
~TC() = delete("deleted (TC<T, int>, Destructor)"); // expected-note {{explicitly marked deleted}}
void* operator new(__SIZE_TYPE__) = delete("deleted (TC<T, int>, New)"); // expected-note {{explicitly deleted}}
void operator delete(void*) = delete("deleted (TC<T, int>, Delete)"); // expected-note {{explicitly marked deleted}}
};
template <>
struct TC<int, int> {
TC() = delete("deleted (TC<int, int>, Constructor)"); // expected-note {{explicitly marked deleted}}
TC(int) = delete("deleted (TC<int, int>, TC(int))"); // expected-note {{explicitly marked deleted}}
TC(const TC&) = delete("deleted (TC<int, int>, Copy Constructor)"); // expected-note {{explicitly marked deleted}}
TC(TC&&) = delete("deleted (TC<int, int>, Move Constructor)"); // expected-note {{explicitly marked deleted}}
TC& operator=(const TC&) = delete("deleted (TC<int, int>, Copy Assignment)"); // expected-note 2 {{explicitly deleted}}
TC& operator=(TC&&) = delete("deleted (TC<int, int>, Move Assignment)"); // expected-note {{explicitly deleted}} expected-note {{not viable}}
~TC() = delete("deleted (TC<int, int>, Destructor)"); // expected-note {{explicitly marked deleted}}
void* operator new(__SIZE_TYPE__) = delete("deleted (TC<int, int>, New)"); // expected-note {{explicitly deleted}}
void operator delete(void*) = delete("deleted (TC<int, int>, Delete)"); // expected-note {{explicitly marked deleted}}
};
void special_members(
C& c1,
C& c2,
TC<double, double>& tc1,
TC<double, double>& tc2,
TC<double, int>& tc_int1,
TC<double, int>& tc_int2,
TC<int, int>& tc_int_int1,
TC<int, int>& tc_int_int2
) {
C{}; // expected-error {{call to deleted constructor of 'C': deleted (C, Constructor)}}
C{c1}; // expected-error {{call to deleted constructor of 'C': deleted (C, Copy Constructor)}}
C{static_cast<C&&>(c1)}; // expected-error {{call to deleted constructor of 'C': deleted (C, Move Constructor)}}
c1 = c2; // expected-error {{overload resolution selected deleted operator '=': deleted (C, Copy Assignment)}}
c1 = static_cast<C&&>(c2); // expected-error {{overload resolution selected deleted operator '=': deleted (C, Move Assignment)}}
c1.~C(); // expected-error {{attempt to use a deleted function: deleted (C, Destructor)}}
new C{}; // expected-error {{call to deleted function 'operator new': deleted (C, New)}}
delete &c2; // expected-error {{attempt to use a deleted function: deleted (C, Delete)}}
TC<double, double>{}; // expected-error {{call to deleted constructor of 'TC<double, double>': deleted (TC, Constructor)}}
TC<double, double>{tc1}; // expected-error {{call to deleted constructor of 'TC<double, double>': deleted (TC, Copy Constructor)}}
TC<double, double>{static_cast<TC<double, double>&&>(tc1)}; // expected-error {{call to deleted constructor of 'TC<double, double>': deleted (TC, Move Constructor)}}
tc1 = tc2; // expected-error {{overload resolution selected deleted operator '=': deleted (TC, Copy Assignment)}}
tc1 = static_cast<TC<double, double>&&>(tc2); // expected-error {{overload resolution selected deleted operator '=': deleted (TC, Move Assignment)}}
tc1.~TC(); // expected-error {{attempt to use a deleted function: deleted (TC, Destructor)}}
new TC<double, double>{}; // expected-error {{call to deleted function 'operator new': deleted (TC, New)}}
delete &tc2; // expected-error {{attempt to use a deleted function: deleted (TC, Delete)}}
TC<double, int>{}; // expected-error {{call to deleted constructor of 'TC<double, int>': deleted (TC<T, int>, Constructor)}}
TC<double, int>{tc_int1}; // expected-error {{call to deleted constructor of 'TC<double, int>': deleted (TC<T, int>, Copy Constructor)}}
TC<double, int>{static_cast<TC<double, int>&&>(tc_int1)}; // expected-error {{call to deleted constructor of 'TC<double, int>': deleted (TC<T, int>, Move Constructor)}}
tc_int1 = tc_int2; // expected-error {{overload resolution selected deleted operator '=': deleted (TC<T, int>, Copy Assignment)}}
tc_int1 = static_cast<TC<double, int>&&>(tc_int2); // expected-error {{overload resolution selected deleted operator '=': deleted (TC<T, int>, Move Assignment)}}
tc_int1.~TC(); // expected-error {{attempt to use a deleted function: deleted (TC<T, int>, Destructor)}}
new TC<double, int>{}; // expected-error {{call to deleted function 'operator new': deleted (TC<T, int>, New)}}
delete &tc_int2; // expected-error {{attempt to use a deleted function: deleted (TC<T, int>, Delete)}}
TC<int, int>{}; // expected-error {{call to deleted constructor of 'TC<int, int>': deleted (TC<int, int>, Constructor)}}
TC<int, int>{tc_int_int1}; // expected-error {{call to deleted constructor of 'TC<int, int>': deleted (TC<int, int>, Copy Constructor)}}
TC<int, int>{static_cast<TC<int, int>&&>(tc_int_int1)}; // expected-error {{call to deleted constructor of 'TC<int, int>': deleted (TC<int, int>, Move Constructor)}}
tc_int_int1 = tc_int_int2; // expected-error {{overload resolution selected deleted operator '=': deleted (TC<int, int>, Copy Assignment)}}
tc_int_int1 = static_cast<TC<int, int>&&>(tc_int_int2); // expected-error {{overload resolution selected deleted operator '=': deleted (TC<int, int>, Move Assignment)}}
tc_int_int1.~TC(); // expected-error {{attempt to use a deleted function: deleted (TC<int, int>, Destructor)}}
new TC<int, int>{}; // expected-error {{call to deleted function 'operator new': deleted (TC<int, int>, New)}}
delete &tc_int_int2; // expected-error {{attempt to use a deleted function: deleted (TC<int, int>, Delete)}}
}
C conv1() { return 1; } // expected-error {{conversion function from 'int' to 'C' invokes a deleted function: deleted (C, C(int))}}
TC<double, double> conv2() { return 1; } // expected-error {{conversion function from 'int' to 'TC<double, double>' invokes a deleted function: deleted (TC, TC(int))}}
TC<double, int> conv3() { return 1; } // expected-error {{conversion function from 'int' to 'TC<double, int>' invokes a deleted function: deleted (TC<T, int>, TC(int))}}
TC<int, int> conv4() { return 1; } // expected-error {{conversion function from 'int' to 'TC<int, int>' invokes a deleted function: deleted (TC<int, int>, TC(int))}}
struct O {
int x;
int operator+() = delete("deleted (O, +)"); // expected-note {{explicitly deleted}}
O* operator->() = delete("deleted (O, ->)"); // expected-note {{explicitly deleted}}
int operator-(O) = delete("deleted (O, -)"); // expected-note {{explicitly deleted}}
int operator[](O) = delete("deleted (O, [])"); // expected-note {{explicitly deleted}}
int operator()(O) = delete("deleted (O, ())"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
explicit operator bool() = delete("deleted (O, operator bool)"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
};
template <typename T, typename U>
struct TO {
T x;
T operator+() = delete("deleted (TO, +)"); // expected-note {{explicitly deleted}}
T* operator->() = delete("deleted (TO, ->)"); // expected-note {{explicitly deleted}}
T operator-(TO) = delete("deleted (TO, -)"); // expected-note {{explicitly deleted}}
T operator[](TO) = delete("deleted (TO, [])"); // expected-note {{explicitly deleted}}
T operator()(TO) = delete("deleted (TO, ())"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
explicit operator bool() = delete("deleted (TO, operator bool)"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
};
template <typename T>
struct TO<T, int> {
T x;
T operator+() = delete("deleted (TO<T, int>, +)"); // expected-note {{explicitly deleted}}
T* operator->() = delete("deleted (TO<T, int>, ->)"); // expected-note {{explicitly deleted}}
T operator-(TO) = delete("deleted (TO<T, int>, -)"); // expected-note {{explicitly deleted}}
T operator[](TO) = delete("deleted (TO<T, int>, [])"); // expected-note {{explicitly deleted}}
T operator()(TO) = delete("deleted (TO<T, int>, ())"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
explicit operator bool() = delete("deleted (TO<T, int>, operator bool)"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
};
template <>
struct TO<int, int> {
int x;
int operator+() = delete("deleted (TO<int, int>, +)"); // expected-note {{explicitly deleted}}
int* operator->() = delete("deleted (TO<int, int>, ->)"); // expected-note {{explicitly deleted}}
int operator-(TO) = delete("deleted (TO<int, int>, -)"); // expected-note {{explicitly deleted}}
int operator[](TO) = delete("deleted (TO<int, int>, [])"); // expected-note {{explicitly deleted}}
int operator()(TO) = delete("deleted (TO<int, int>, ())"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
explicit operator bool() = delete("deleted (TO<int, int>, operator bool)"); // expected-note {{explicitly marked deleted}} expected-note {{explicitly deleted}}
};
void operators() {
O o;
+o; // expected-error {{overload resolution selected deleted operator '+': deleted (O, +)}}
o->x; // expected-error {{overload resolution selected deleted operator '->': deleted (O, ->)}}
o - o; // expected-error {{overload resolution selected deleted operator '-': deleted (O, -)}}
o[o]; // expected-error {{overload resolution selected deleted operator '[]': deleted (O, [])}}
o(o); // expected-error {{call to deleted function call operator in type 'O': deleted (O, ())}} expected-error {{attempt to use a deleted function: deleted (O, ())}}
if (o) {} // expected-error {{attempt to use a deleted function: deleted (O, operator bool)}}
static_cast<bool>(o); // expected-error {{static_cast from 'O' to 'bool' uses deleted function: deleted (O, operator bool)}}
TO<double, double> to;
+to; // expected-error {{overload resolution selected deleted operator '+': deleted (TO, +)}}
to->x; // expected-error {{overload resolution selected deleted operator '->': deleted (TO, ->)}}
to - to; // expected-error {{overload resolution selected deleted operator '-': deleted (TO, -)}}
to[to]; // expected-error {{overload resolution selected deleted operator '[]': deleted (TO, [])}}
to(to); // expected-error {{call to deleted function call operator in type 'TO<double, double>': deleted (TO, ())}} expected-error {{attempt to use a deleted function: deleted (TO, ())}}
if (to) {} // expected-error {{attempt to use a deleted function: deleted (TO, operator bool)}}
static_cast<bool>(to); // expected-error {{static_cast from 'TO<double, double>' to 'bool' uses deleted function: deleted (TO, operator bool)}}
TO<double, int> to_int;
+to_int; // expected-error {{overload resolution selected deleted operator '+': deleted (TO<T, int>, +)}}
to_int->x; // expected-error {{overload resolution selected deleted operator '->': deleted (TO<T, int>, ->)}}
to_int - to_int; // expected-error {{overload resolution selected deleted operator '-': deleted (TO<T, int>, -)}}
to_int[to_int]; // expected-error {{overload resolution selected deleted operator '[]': deleted (TO<T, int>, [])}}
to_int(to_int); // expected-error {{call to deleted function call operator in type 'TO<double, int>': deleted (TO<T, int>, ())}} expected-error {{attempt to use a deleted function: deleted (TO<T, int>, ())}}
if (to_int) {} // expected-error {{attempt to use a deleted function: deleted (TO<T, int>, operator bool)}}
static_cast<bool>(to_int); // expected-error {{static_cast from 'TO<double, int>' to 'bool' uses deleted function: deleted (TO<T, int>, operator bool)}}
TO<int, int> to_int_int;
+to_int_int; // expected-error {{overload resolution selected deleted operator '+': deleted (TO<int, int>, +)}}
to_int_int->x; // expected-error {{overload resolution selected deleted operator '->': deleted (TO<int, int>, ->)}}
to_int_int - to_int_int; // expected-error {{overload resolution selected deleted operator '-': deleted (TO<int, int>, -)}}
to_int_int[to_int_int]; // expected-error {{overload resolution selected deleted operator '[]': deleted (TO<int, int>, [])}}
to_int_int(to_int_int); // expected-error {{call to deleted function call operator in type 'TO<int, int>': deleted (TO<int, int>, ())}} expected-error {{attempt to use a deleted function: deleted (TO<int, int>, ())}}
if (to_int_int) {} // expected-error {{attempt to use a deleted function: deleted (TO<int, int>, operator bool)}}
static_cast<bool>(to_int_int); // expected-error {{static_cast from 'TO<int, int>' to 'bool' uses deleted function: deleted (TO<int, int>, operator bool)}}
};
Codebase Browser
llvm