274 lines
8.4 KiB
C++
274 lines
8.4 KiB
C++
// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,cxx11-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,cxx11-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx20 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx20,since-cxx23 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx20,since-cxx23 -fexceptions -fcxx-exceptions -pedantic-errors
|
|
|
|
#if __cplusplus == 199711L
|
|
// expected-no-diagnostics
|
|
#endif
|
|
|
|
namespace dr2516 { // dr2516: 3.0
|
|
// NB: reusing 1482 test
|
|
#if __cplusplus >= 201103L
|
|
template <typename T> struct S {
|
|
typedef char I;
|
|
};
|
|
enum E2 : S<E2>::I { e };
|
|
// since-cxx11-error@-1 {{use of undeclared identifier 'E2'}}
|
|
#endif
|
|
} // namespace dr2516
|
|
|
|
namespace dr2518 { // dr2518: 17
|
|
|
|
#if __cplusplus >= 201103L
|
|
template <class T>
|
|
void f(T t) {
|
|
if constexpr (sizeof(T) != sizeof(int)) {
|
|
// cxx11-14-error@-1 {{constexpr if is a C++17 extension}}
|
|
static_assert(false, "must be int-sized");
|
|
// since-cxx11-error@-1 {{static assertion failed: must be int-sized}}
|
|
// since-cxx11-note@#dr2518-f-c {{in instantiation of function template specialization 'dr2518::f<char>' requested here}}
|
|
}
|
|
}
|
|
|
|
void g(char c) {
|
|
f(0);
|
|
f(c); // #dr2518-f-c
|
|
}
|
|
|
|
template <typename Ty>
|
|
struct S {
|
|
static_assert(false);
|
|
// cxx11-14-error@-1 {{'static_assert' with no message is a C++17 extension}}
|
|
// since-cxx11-error@-2 {{static assertion failed}}
|
|
// since-cxx11-note@#dr2518-S-double {{in instantiation of template class 'dr2518::S<double>' requested here}}
|
|
};
|
|
|
|
template <>
|
|
struct S<int> {};
|
|
|
|
template <>
|
|
struct S<float> {};
|
|
|
|
int test_specialization() {
|
|
S<int> s1;
|
|
S<float> s2;
|
|
S<double> s3; // #dr2518-S-double
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
namespace dr2521 { // dr2521: 17
|
|
#if __cplusplus >= 201103L
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic warning "-Wdeprecated-literal-operator"
|
|
long double operator"" _\u03C0___(long double);
|
|
// since-cxx11-warning@-1 {{identifier '_π___' preceded by whitespace in a literal operator declaration is deprecated}}
|
|
// since-cxx11-warning@-2 {{user-defined literal suffixes containing '__' are reserved}}
|
|
|
|
template <char... Chars> decltype(sizeof 0)
|
|
operator"" _div();
|
|
// since-cxx11-warning@-1 {{identifier '_div' preceded by whitespace in a literal operator declaration is deprecated}}
|
|
|
|
using ::dr2521::operator"" _\u03C0___;
|
|
using ::dr2521::operator""_div;
|
|
// since-cxx11-warning@-2 {{identifier '_π___' preceded by whitespace in a literal operator declaration is deprecated}}
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
} // namespace dr2521
|
|
|
|
|
|
#if __cplusplus >= 202302L
|
|
namespace dr2553 { // dr2553: 18 review
|
|
struct B {
|
|
virtual void f(this B&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a virtual function}}
|
|
static void f(this B&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a static function}}
|
|
virtual void g(); // #dr2553-g
|
|
};
|
|
struct D : B {
|
|
void g(this D&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a virtual function}}
|
|
// since-cxx23-note@#dr2553-g {{overridden virtual function is here}}
|
|
};
|
|
|
|
}
|
|
#endif
|
|
|
|
#if __cplusplus >= 202302L
|
|
namespace dr2554 { // dr2554: 18 review
|
|
struct B {
|
|
virtual void f(); // #dr2554-g
|
|
};
|
|
|
|
struct D : B {
|
|
void f(this D&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a virtual function}}
|
|
// since-cxx23-note@#dr2554-g {{overridden virtual function is here}}
|
|
};
|
|
|
|
struct D2 : B {
|
|
void f(this B&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a virtual function}}
|
|
// since-cxx23-note@#dr2554-g {{overridden virtual function is here}}
|
|
};
|
|
struct T {};
|
|
struct D3 : B {
|
|
void f(this T&);
|
|
// since-cxx23-error@-1 {{an explicit object parameter cannot appear in a virtual function}}
|
|
// since-cxx23-note@#dr2554-g {{overridden virtual function is here}}
|
|
};
|
|
|
|
}
|
|
#endif
|
|
|
|
#if __cplusplus >= 202302L
|
|
namespace dr2561 { // dr2561: 18 review
|
|
struct C {
|
|
constexpr C(auto) { }
|
|
};
|
|
void foo() {
|
|
constexpr auto b = [](this C) { return 1; };
|
|
constexpr int (*fp)(C) = b;
|
|
static_assert(fp(1) == 1);
|
|
static_assert((&decltype(b)::operator())(1) == 1);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
namespace dr2565 { // dr2565: 16 open
|
|
#if __cplusplus >= 202002L
|
|
template<typename T>
|
|
concept C = requires (typename T::type x) {
|
|
x + 1;
|
|
};
|
|
static_assert(!C<int>);
|
|
|
|
// Variant of this as reported in GH57487.
|
|
template<bool B> struct bool_constant
|
|
{ static constexpr bool value = B; };
|
|
|
|
template<typename T>
|
|
using is_referenceable
|
|
= bool_constant<requires (T&) { true; }>;
|
|
|
|
static_assert(!is_referenceable<void>::value);
|
|
static_assert(is_referenceable<int>::value);
|
|
|
|
template<typename T, typename U>
|
|
concept TwoParams = requires (T *a, U b){ true;}; // #dr2565-TPC
|
|
|
|
template<typename T, typename U>
|
|
requires TwoParams<T, U> // #dr2565-TPSREQ
|
|
struct TwoParamsStruct{};
|
|
|
|
using TPSU = TwoParamsStruct<void, void>;
|
|
// since-cxx20-error@-1 {{constraints not satisfied for class template 'TwoParamsStruct'}}
|
|
// since-cxx20-note@#dr2565-TPSREQ {{because 'TwoParams<void, void>' evaluated to false}}
|
|
// since-cxx20-note@#dr2565-TPC {{because 'b' would be invalid: argument may not have 'void' type}}
|
|
|
|
template<typename T, typename ...U>
|
|
concept Variadic = requires (U* ... a, T b){ true;}; // #dr2565-VC
|
|
|
|
template<typename T, typename ...U>
|
|
requires Variadic<T, U...> // #dr2565-VSREQ
|
|
struct VariadicStruct{};
|
|
|
|
using VSU = VariadicStruct<void, int, char, double>;
|
|
// since-cxx20-error@-1 {{constraints not satisfied for class template 'VariadicStruct'}}
|
|
// since-cxx20-note@#dr2565-VSREQ {{because 'Variadic<void, int, char, double>' evaluated to false}}
|
|
// since-cxx20-note@#dr2565-VC {{because 'b' would be invalid: argument may not have 'void' type}}
|
|
|
|
template<typename T>
|
|
concept ErrorRequires = requires (ErrorRequires auto x) {
|
|
// since-cxx20-error@-1 {{unknown type name 'ErrorRequires'}}
|
|
x;
|
|
};
|
|
static_assert(ErrorRequires<int>);
|
|
// since-cxx20-error@-1 {{static assertion failed}}
|
|
// since-cxx20-note@-2 {{because substituted constraint expression is ill-formed: constraint depends on a previously diagnosed expression}}
|
|
|
|
template<typename T>
|
|
concept NestedErrorInRequires = requires (T x) {
|
|
requires requires (NestedErrorInRequires auto y) {
|
|
// since-cxx20-error@-1 {{unknown type name 'NestedErrorInRequires'}}
|
|
y;
|
|
};
|
|
};
|
|
static_assert(NestedErrorInRequires<int>);
|
|
// expected-error@-1 {{static assertion failed}}
|
|
// expected-note@-2 {{because substituted constraint expression is ill-formed: constraint depends on a previously diagnosed expression}}
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
namespace dr2598 { // dr2598: 18
|
|
#if __cplusplus >= 201103L
|
|
struct NonLiteral {
|
|
NonLiteral();
|
|
};
|
|
|
|
struct anonymous1 {
|
|
union {} a;
|
|
};
|
|
static_assert(__is_literal(anonymous1), "");
|
|
|
|
struct anonymous2 {
|
|
union { char c; };
|
|
};
|
|
static_assert(__is_literal(anonymous2), "");
|
|
|
|
struct anonymous3 {
|
|
union { char c; NonLiteral NL; };
|
|
};
|
|
static_assert(__is_literal(anonymous3), "");
|
|
|
|
struct anonymous4 {
|
|
union { NonLiteral NL; };
|
|
};
|
|
static_assert(!__is_literal(anonymous4), "");
|
|
|
|
union empty {};
|
|
static_assert(__is_literal(empty), "");
|
|
|
|
union union1 { char c; };
|
|
static_assert(__is_literal(union1), "");
|
|
|
|
union union2 { char c; NonLiteral NL;};
|
|
static_assert(__is_literal(union2), "");
|
|
|
|
union union3 { NonLiteral NL;};
|
|
static_assert(!__is_literal(union3), "");
|
|
|
|
union union4 { union4(); };
|
|
static_assert(!__is_literal(union4), "");
|
|
|
|
union union5 { static NonLiteral NL; };
|
|
static_assert(__is_literal(union5), "");
|
|
|
|
struct Literal { constexpr Literal() {} };
|
|
union union6 { NonLiteral NL; Literal L; };
|
|
static_assert(__is_literal(union6), "");
|
|
|
|
#if __cplusplus >= 202003L
|
|
struct A { A(); };
|
|
union U {
|
|
A a;
|
|
constexpr U() {}
|
|
constexpr ~U() {}
|
|
};
|
|
static_assert(!__is_literal(U), "");
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
}
|