pr7675(10.0);
pr7675(10);
pr7675('c');
- pr7675_i(4.0i);
+ pr7675_i(4.0j);
// Add check to ensure we are analyzing the code up to this point.
clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
// RUN: %clang_cc1 -fsyntax-only -verify %s
// C++'0x [class.friend] p1:
struct A {};
struct B {
- friend A::A();
+ friend
+#if __cplusplus >= 201103L
+ constexpr
+#endif
+ A::A();
friend A::~A();
- friend A &A::operator=(const A&);
+ friend
+#if __cplusplus >= 201402L
+ constexpr
+#endif
+ A &A::operator=(const A&);
};
}
class A {
friend void X<int>::foo();
friend X<int>::X();
- friend X<int>::X(const X&);
+ friend
+#if __cplusplus >= 201103L
+ constexpr
+#endif
+ X<int>::X(const X&);
private:
A(); // expected-note 2 {{declared private here}}
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
// C++0x [class.access]p4:
namespace test2 {
class A {
private:
- A(); // expected-note 3 {{declared private here}}
+ A(); // expected-note 1+{{declared private here}}
static A foo;
};
A a; // expected-error {{calling a private constructor}}
A A::foo; // okay
+#if __cplusplus < 201103L
class B : A { }; // expected-error {{base class 'test2::A' has private default constructor}}
B b; // expected-note{{implicit default constructor}}
class D : C { }; // expected-error {{inherited virtual base class 'test2::A' has private default constructor}}
D d; // expected-note{{implicit default constructor}}
+#else
+ class B : A { }; // expected-note {{base class 'test2::A' has an inaccessible default constructor}}
+ B b; // expected-error {{call to implicitly-deleted default constructor}}
+
+ // FIXME: Do a better job of explaining how we get here from class D.
+ class C : virtual A { // expected-note {{default constructor of 'D' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
+ public:
+ C();
+ };
+
+ class D : C { };
+ D d; // expected-error {{call to implicitly-deleted default constructor}}
+#endif
}
// Implicit destructor calls.
A local; // expected-error {{variable of type 'test3::A' has private destructor}}
}
+#if __cplusplus < 201103L
template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}
class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \
// expected-error {{base class 'Base<2>' has private destructor}}
{};
Derived3 d3; // expected-note {{implicit default constructor}}\
// expected-note{{implicit destructor}}}
+#else
+ template <unsigned N> class Base { ~Base(); }; // expected-note 4{{declared private here}}
+ class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 1{{declared private here}}
+ class Base3 : virtual Base<3> { public: ~Base3(); };
+
+ // These don't cause diagnostics because we don't need the destructor.
+ class Derived0 : Base<0> { ~Derived0(); };
+ class Derived1 : Base<1> { };
+
+ class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
+ // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
+ Base<0>, // expected-error {{base class 'Base<0>' has private destructor}}
+ virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
+ Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
+ virtual Base3
+ {
+ ~Derived2() {}
+ };
+
+ class Derived3 :
+ Base<0>, // expected-note {{deleted because base class 'Base<0>' has an inaccessible destructor}}
+ virtual Base<1>,
+ Base2,
+ virtual Base3
+ {};
+ Derived3 d3; // expected-error {{implicitly-deleted default constructor}}
+#endif
}
// Conversion functions.
// Implicit copy assignment operator uses.
namespace test5 {
class A {
- void operator=(const A &); // expected-note 2 {{implicitly declared private here}}
+ void operator=(const A &);
+#if __cplusplus < 201103L
+ // expected-note@-2 2{{implicitly declared private here}}
+#endif
};
+#if __cplusplus < 201103L
class Test1 { A a; }; // expected-error {{private member}}
void test1() {
Test1 a;
Test2 a;
a = Test2(); // expected-note{{implicit copy}}
}
+#else
+ class Test1 { A a; }; // expected-note {{because field 'a' has an inaccessible copy assignment operator}}
+ void test1() {
+ Test1 a;
+ a = Test1(); // expected-error {{copy assignment operator is implicitly deleted}}
+ }
+
+ class Test2 : A {}; // expected-note {{because base class 'test5::A' has an inaccessible copy assignment operator}}
+ void test2() {
+ Test2 a;
+ a = Test2(); // expected-error {{copy assignment operator is implicitly deleted}}
+ }
+#endif
}
// Implicit copy constructor uses.
namespace test6 {
class A {
public: A();
- private: A(const A &); // expected-note 2 {{declared private here}}
+ private: A(const A &);
+#if __cplusplus < 201103L
+ // expected-note@-2 2{{declared private here}}
+#endif
};
+#if __cplusplus < 201103L
class Test1 { A a; }; // expected-error {{field of type 'test6::A' has private copy constructor}}
void test1(const Test1 &t) {
Test1 a = t; // expected-note{{implicit copy}}
void test2(const Test2 &t) {
Test2 a = t; // expected-note{{implicit copy}}
}
+#else
+ class Test1 { A a; }; // expected-note {{field 'a' has an inaccessible copy constructor}}
+ void test1(const Test1 &t) {
+ Test1 a = t; // expected-error{{implicitly-deleted}}
+ }
+
+ class Test2 : A {}; // expected-note {{base class 'test6::A' has an inaccessible copy constructor}}
+ void test2(const Test2 &t) {
+ Test2 a = t; // expected-error{{implicitly-deleted}}
+ }
+#endif
}
// Redeclaration lookups are not accesses.
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
void abort() __attribute__((noreturn));
-// RUN: %clang_cc1 -fsyntax-only -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
// Verify that the appropriate fixits are emitted for narrowing conversions in
// initializer lists.
-// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++03 -fdiagnostics-show-option -Wbind-to-temporary-copy -verify %s
// C++03 requires that we check for a copy constructor when binding a
// reference to a temporary, since we are allowed to make a copy, Even
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// RUN: %clang_cc1 -fsyntax-only -verify %s
// A program that calls for default-initialization or value-initialization of
// cv-unqualified version of T is used for these definitions of
// zero-initialization, default-initialization, and value-initialization.
+typedef int &IR;
+IR r; // expected-error {{declaration of reference variable 'r' requires an initializer}}
+int n = IR(); // expected-error {{reference to type 'int' requires an initializer}}
+
+#if __cplusplus < 201103L
struct S { // expected-error {{implicit default constructor for 'S' must explicitly initialize the reference member}}
int &x; // expected-note {{declared here}} expected-error 3{{reference to type 'int' requires an initializer}}
};
T t[3]; // expected-note {{in value-initialization of type 'T' here}}
};
U u = U(); // expected-note {{in value-initialization of type 'U' here}}
+#else
+struct S {
+ int &x; // expected-note 4{{because field 'x' of reference type 'int &' would not be initialized}}
+};
+S s; // expected-error {{deleted default constructor}}
+S f() {
+ return S(); // expected-error {{deleted default constructor}}
+}
+
+struct T
+ : S { // expected-note 2{{because base class 'S' has a deleted default constructor}}
+};
+T t = T(); // expected-error {{deleted default constructor}}
+
+struct U {
+ T t[3]; // expected-note {{because field 't' has a deleted default constructor}}
+};
+U u = U(); // expected-error {{deleted default constructor}}
+#endif
// Ensure that we handle C++11 in-class initializers properly as an extension.
// In this case, there is no user-declared default constructor, so we
// constructor call anyway, because the default constructor is not trivial.
struct V {
int n;
- int &r = n; // expected-warning {{C++11}}
+ int &r = n; // expected-warning 0-1{{C++11}}
};
V v = V(); // ok
struct W {
int n;
- S s = { n }; // expected-warning {{C++11}}
+ S s = { n }; // expected-warning 0-1{{C++11}}
};
W w = W(); // ok
// Ensure we're not faking this up by making the default constructor
// non-trivial.
-#define static_assert(B, S) typedef int assert_failed[(B) ? 1 : -1];
-static_assert(__has_trivial_constructor(S), "");
-static_assert(__has_trivial_constructor(T), "");
-static_assert(__has_trivial_constructor(U), "");
-static_assert(!__has_trivial_constructor(V), "");
-static_assert(!__has_trivial_constructor(W), "");
+_Static_assert(__has_trivial_constructor(S), "");
+_Static_assert(__has_trivial_constructor(T), "");
+_Static_assert(__has_trivial_constructor(U), "");
+_Static_assert(!__has_trivial_constructor(V), "");
+_Static_assert(!__has_trivial_constructor(W), "");
-// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
-// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
-typedef typeof(sizeof(int)) size_t;
+typedef __typeof(sizeof(int)) size_t;
// PR7803
namespace test0 {
};
B::~B() {} // expected-error {{no suitable member 'operator delete' in 'B'}}
+#if __cplusplus < 201103L
struct CBase { virtual ~CBase(); };
struct C : CBase { // expected-error {{no suitable member 'operator delete' in 'C'}}
static void operator delete(void*, const int &); // expected-note {{declared here}}
void test() {
C c; // expected-note {{first required here}}
}
+#else
+ struct CBase { virtual ~CBase(); }; // expected-note {{overridden virtual function is here}}
+ struct C : CBase { // expected-error {{deleted function '~C' cannot override a non-deleted function}} expected-note {{requires an unambiguous, accessible 'operator delete'}}
+ static void operator delete(void*, const int &);
+ };
+ void test() {
+ C c; // expected-error {{attempt to use a deleted function}}
+ }
+#endif
}
// PR7346
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s
// RUN: %clang_cc1 -fsyntax-only -verify %s
// C++0x [temp.arg.nontype] p5:
operator int() const;
};
- template<X const *Ptr> struct A2; // expected-note{{template parameter is declared here}}
+ template<X const *Ptr> struct A2; // expected-note 0-1{{template parameter is declared here}}
- X *X_ptr;
+ X *X_ptr; // expected-note 0-1{{declared here}}
X an_X;
X array_of_Xs[10];
- A2<X_ptr> *a12; // expected-error{{must have its address taken}}
+ A2<X_ptr> *a12;
+#if __cplusplus < 201103L
+ // expected-error@-2 {{must have its address taken}}
+#else
+ // expected-error@-4 {{not a constant expression}} expected-note@-4 {{read of non-constexpr variable}}
+#endif
A2<array_of_Xs> *a13;
A2<&an_X> *a13_2;
- A2<(&an_X)> *a13_3; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
+ A2<(&an_X)> *a13_3;
+#if __cplusplus < 201103L
+ // expected-warning@-2 {{address non-type template argument cannot be surrounded by parentheses}}
+#endif
// PR6244
struct X1 {} X1v;
struct X4 : X3<&X1v> { };
// PR6563
- int *bar;
- template <int *> struct zed {}; // expected-note 2{{template parameter is declared here}}
- void g(zed<bar>*); // expected-error{{must have its address taken}}
-
- int baz;
- void g2(zed<baz>*); // expected-error{{must have its address taken}}
+ int *bar; // expected-note 0-1{{declared here}}
+ template <int *> struct zed {}; // expected-note 0-2{{template parameter is declared here}}
+ void g(zed<bar>*);
+#if __cplusplus < 201103L
+ // expected-error@-2 {{must have its address taken}}
+#else
+ // expected-error@-4 {{not a constant expression}} expected-note@-4 {{read of non-constexpr variable}}
+#endif
+
+ int baz; // expected-note 0-1{{declared here}}
+ void g2(zed<baz>*);
+#if __cplusplus < 201103L
+ // expected-error@-2 {{must have its address taken}}
+#elif __cplusplus <= 201402L
+ // expected-error@-4 {{not a constant expression}} expected-note@-4 {{read of non-const variable}}
+#else
+ // expected-error@-6 {{not implicitly convertible to 'int *'}}
+#endif
void g3(zed<&baz>*); // okay
}
// template-argument. The template-parameter is bound directly to the
// template-argument, which shall be an lvalue.
namespace reference_parameters {
- template <int& N> struct S0 { }; // expected-note 3 {{template parameter is declared here}}
- template <const int& N> struct S1 { }; // expected-note 2 {{template parameter is declared here}}
- template <volatile int& N> struct S2 { }; // expected-note 2 {{template parameter is declared here}}
+ template <int& N> struct S0 { }; // expected-note 0-3{{template parameter is declared here}}
+ template <const int& N> struct S1 { }; // expected-note 0-2{{template parameter is declared here}}
+ template <volatile int& N> struct S2 { }; // expected-note 0-2{{template parameter is declared here}}
template <const volatile int& N> struct S3 { };
int i;
extern const int ci;
extern const volatile int cvi;
void test() {
S0<i> s0;
- S0<ci> s0c; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const int' ignores qualifiers}}
- S0<vi> s0v; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'volatile int' ignores qualifiers}}
- S0<cvi> s0cv; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const volatile int' ignores qualifiers}}
+ S0<ci> s0c; // expected-error{{type 'const int'}}
+ S0<vi> s0v; // expected-error{{type 'volatile int'}}
+ S0<cvi> s0cv; // expected-error{{type 'const volatile int'}}
S1<i> s1;
S1<ci> s1c;
- S1<vi> s1v; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'volatile int' ignores qualifiers}}
- S1<cvi> s1cv; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'const volatile int' ignores qualifiers}}
+ S1<vi> s1v; // expected-error{{type 'volatile int'}}
+ S1<cvi> s1cv; // expected-error{{type 'const volatile int'}}
S2<i> s2;
- S2<ci> s2c; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const int' ignores qualifiers}}
+ S2<ci> s2c; // expected-error{{type 'const int'}}
S2<vi> s2v;
- S2<cvi> s2cv; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const volatile int' ignores qualifiers}}
+ S2<cvi> s2cv; // expected-error{{type 'const volatile int'}}
S3<i> s3;
S3<ci> s3c;
}
namespace PR6749 {
- template <int& i> struct foo {}; // expected-note{{template parameter is declared here}}
+ template <int& i> struct foo {}; // expected-note 0-1{{template parameter is declared here}}
int x, &y = x;
- foo<y> f; // expected-error{{is not an object}}
+ foo<y> f;
+#if __cplusplus <= 201402L
+ // expected-error@-2 {{is not an object}}
+#endif
}
}
// a set of overloaded functions (or a pointer to such), the matching
// function is selected from the set (13.4).
namespace pointer_to_function {
- template<int (*)(int)> struct X0 { }; // expected-note 3{{template parameter is declared here}}
+ template<int (*)(int)> struct X0 { }; // expected-note 0-3{{template parameter is declared here}}
int f(int);
int f(float);
int g(float);
- int (*funcptr)(int);
+ int (*funcptr)(int); // expected-note 0-1{{declared here}}
void x0a(X0<f>);
void x0b(X0<&f>);
- void x0c(X0<g>); // expected-error{{non-type template argument of type 'int (float)' cannot be converted to a value of type 'int (*)(int)'}}
- void x0d(X0<&g>); // expected-error{{non-type template argument of type 'int (*)(float)' cannot be converted to a value of type 'int (*)(int)'}}
- void x0e(X0<funcptr>); // expected-error{{must have its address taken}}
+ void x0c(X0<g>); // expected-error-re{{type 'int (float)' {{.*}}convert{{.*}} 'int (*)(int)'}}
+ void x0d(X0<&g>); // expected-error-re{{type 'int (*)(float)' {{.*}}convert{{.*}} 'int (*)(int)'}}
+ void x0e(X0<funcptr>);
+#if __cplusplus < 201103L
+ // expected-error@-2 {{must have its address taken}}
+#else
+ // expected-error@-4 {{not a constant expression}} expected-note@-4 {{read of non-constexpr variable}}
+#endif
}
// -- For a non-type template-parameter of type reference to function, no
// overloaded functions, the matching function is selected from the set
// (13.4).
namespace reference_to_function {
- template<int (&)(int)> struct X0 { }; // expected-note 4{{template parameter is declared here}}
+ template<int (&)(int)> struct X0 { }; // expected-note 0-4{{template parameter is declared here}}
int f(int);
int f(float);
int g(float);
int (*funcptr)(int);
void x0a(X0<f>);
+#if __cplusplus <= 201402L
void x0b(X0<&f>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
void x0c(X0<g>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (float)'}}
void x0d(X0<&g>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
void x0e(X0<funcptr>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (*)(int)'}}
+#else
+ void x0b(X0<&f>); // expected-error{{value of type '<overloaded function type>' is not implicitly convertible to 'int (&)(int)'}}
+ void x0c(X0<g>); // expected-error{{value of type 'int (float)' is not implicitly convertible to 'int (&)(int)'}}
+ void x0d(X0<&g>); // expected-error{{value of type 'int (*)(float)' is not implicitly convertible to 'int (&)(int)'}}
+ void x0e(X0<funcptr>); // expected-error{{value of type 'int (*)(int)' is not implicitly convertible to 'int (&)(int)'}}
+#endif
}
// -- For a non-type template-parameter of type pointer to member function,
// if the template-argument is of type std::nullptr_t, the null member
float h(float);
};
- template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}}
+ template<int (Y::*)(int)> struct X0 {}; // expected-note 0-1{{template parameter is declared here}}
X0<&Y::f> x0a;
X0<&Y::g> x0b;
- X0<&Y::h> x0c; // expected-error-re{{non-type template argument of type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
+ X0<&Y::h> x0c; // expected-error-re{{type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' {{.*}} convert{{.*}} 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
}
// -- For a non-type template-parameter of type pointer to data member,
struct X { int x; };
struct Y : X { int y; };
- template<int Y::*> struct X0 {}; // expected-note{{template parameter is declared here}}
+ template<int Y::*> struct X0 {}; // expected-note 0-1{{template parameter is declared here}}
X0<&Y::y> x0a;
- X0<&Y::x> x0b; // expected-error{{non-type template argument of type 'int pointer_to_member_data::X::*' cannot be converted to a value of type 'int pointer_to_member_data::Y::*'}}
+ X0<&Y::x> x0b;
+#if __cplusplus <= 201402L
+ // expected-error@-2 {{non-type template argument of type 'int pointer_to_member_data::X::*' cannot be converted to a value of type 'int pointer_to_member_data::Y::*'}}
+#else
+ // expected-error@-4 {{conversion from 'int pointer_to_member_data::X::*' to 'int pointer_to_member_data::Y::*' is not allowed in a converted constant expression}}
+#endif
// Test qualification conversions
template<const int Y::*> struct X1 {};
return X0<X2>::value; // expected-note{{instantiation}}
}
-template<typename T> T x; // expected-warning{{variable templates are a C++14 extension}}
+template<typename T> T x; // expected-warning 0-1{{variable templates are a C++14 extension}}
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// RUN: %clang_cc1 -fsyntax-only -verify %s
-struct IntHolder { // expected-note{{here}} // expected-note 2{{candidate constructor (the implicit copy constructor)}}
+struct IntHolder { // expected-note 0-1{{here}} expected-note 2-4{{candidate constructor (the implicit}}
IntHolder(int); // expected-note 2{{candidate constructor}}
};
void g() { }
- struct Inner { // expected-error{{implicit default}}
+ struct Inner {
+#if __cplusplus >= 201103L
+ T value; // expected-note {{has no default constructor}}
+#else
+ // expected-error@-4 {{implicit default}}
T value; // expected-note {{member is declared here}}
+#endif
};
static T value;
xih.g(); // okay
xih.f(); // expected-note{{instantiation}}
- X<IntHolder, int>::Inner inner; // expected-note {{first required here}}
+ X<IntHolder, int>::Inner inner;
+#if __cplusplus >= 201103L
+ // expected-error@-2 {{call to implicitly-deleted}}
+#else
+ // expected-note@-4 {{first required here}}
+#endif
return X<IntHolder, int>::value; // expected-note{{instantiation}}
}
projects / clang / commitdiff