1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens %s
// RUN: cp %s %t
// RUN: not %clang_cc1 -x c++ -std=c++11 -fixit %t
// RUN: %clang_cc1 -Wall -pedantic -x c++ -std=c++11 %t
/* This is a test of the various code modification hints that only
apply in C++0x. */
struct A {
explicit operator int(); // expected-note{{conversion to integral type}}
};
void x() {
switch(A()) { // expected-error{{explicit conversion to}}
}
}
using ::T = void; // expected-error {{name defined in alias declaration must be an identifier}}
using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}}
using typename ::V = void; // expected-error {{name defined in alias declaration must be an identifier}}
namespace SemiCommaTypo {
int m {},
n [[]], // expected-error {{expected ';' at end of declaration}}
int o;
struct Base {
virtual void f2(), f3();
};
struct MemberDeclarator : Base {
int k : 4,
//[[]] : 1, FIXME: test this once we support attributes here
: 9, // expected-error {{expected ';' at end of declaration}}
char c, // expected-error {{expected ';' at end of declaration}}
typedef void F(), // expected-error {{expected ';' at end of declaration}}
F f1,
f2 final,
f3 override, // expected-error {{expected ';' at end of declaration}}
};
}
namespace ScopedEnum {
enum class E { a };
enum class E b = E::a; // expected-error {{must use 'enum' not 'enum class'}}
struct S {
friend enum class E; // expected-error {{must use 'enum' not 'enum class'}}
};
}
struct S2 {
void f(int i);
void g(int i);
};
void S2::f(int i) {
(void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}}
(void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
(void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
(void)[] mutable { }; // expected-error{{lambda requires '()' before 'mutable'}}
(void)[] -> int { }; // expected-error{{lambda requires '()' before return type}}
}
#define bar "bar"
const char *p = "foo"bar; // expected-error {{requires a space between}}
#define ord - '0'
int k = '4'ord; // expected-error {{requires a space between}}
void operator"x" _y(char); // expected-error {{must be '""'}}
void operator L"" _z(char); // expected-error {{encoding prefix}}
void operator "x" "y" U"z" ""_whoops "z" "y"(char); // expected-error {{must be '""'}}
void f() {
'b'_y;
'c'_z;
'd'_whoops;
}
template<typename ...Ts> struct MisplacedEllipsis {
int a(Ts ...(x)); // expected-error {{'...' must immediately precede declared identifier}}
int b(Ts ...&x); // expected-error {{'...' must immediately precede declared identifier}}
int c(Ts ...&); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
int d(Ts ...(...&...)); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
int e(Ts ...*[]); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
int f(Ts ...(...*)()); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
int g(Ts ...()); // ok
};
namespace TestMisplacedEllipsisRecovery {
MisplacedEllipsis<int, char> me;
int i; char k;
int *ip; char *kp;
int ifn(); char kfn();
int a = me.a(i, k);
int b = me.b(i, k);
int c = me.c(i, k);
int d = me.d(i, k);
int e = me.e(&ip, &kp);
int f = me.f(ifn, kfn);
int g = me.g(ifn, kfn);
}
template<template<typename> ...Foo, // expected-error {{template template parameter requires 'class' after the parameter list}}
template<template<template<typename>>>> // expected-error 3 {{template template parameter requires 'class' after the parameter list}}
void func();
template<int *ip> struct IP { }; // expected-note{{declared here}}
IP<0> ip0; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}}
namespace MissingSemi {
struct a // expected-error {{expected ';' after struct}}
struct b // expected-error {{expected ';' after struct}}
enum x : int { x1, x2, x3 } // expected-error {{expected ';' after enum}}
struct c // expected-error {{expected ';' after struct}}
enum x : int // expected-error {{expected ';' after enum}}
// FIXME: The following gives a poor diagnostic (we parse the 'int' and the
// 'struct' as part of the same enum-base.
// enum x : int
// struct y
namespace N {
struct d // expected-error {{expected ';' after struct}}
}
}
namespace NonStaticConstexpr {
struct foo {
constexpr int i; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
constexpr int j = 7; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
constexpr const int k; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
foo() : i(3), k(4) {
}
static int get_j() {
return j;
}
};
}
int RegisterVariable() {
register int n; // expected-warning {{'register' storage class specifier is deprecated}}
return n;
}
namespace MisplacedParameterPack {
template <typename Args...> // expected-error {{'...' must immediately precede declared identifier}}
void misplacedEllipsisInTypeParameter(Args...);
template <typename... Args...> // expected-error {{'...' must immediately precede declared identifier}}
void redundantEllipsisInTypeParameter(Args...);
template <template <typename> class Args...> // expected-error {{'...' must immediately precede declared identifier}}
void misplacedEllipsisInTemplateTypeParameter(Args<int>...);
template <template <typename> class... Args...> // expected-error {{'...' must immediately precede declared identifier}}
void redundantEllipsisInTemplateTypeParameter(Args<int>...);
template <int N...> // expected-error {{'...' must immediately precede declared identifier}}
void misplacedEllipsisInNonTypeTemplateParameter();
template <int... N...> // expected-error {{'...' must immediately precede declared identifier}}
void redundantEllipsisInNonTypeTemplateParameter();
}
namespace MisplacedDeclAndRefSpecAfterVirtSpec {
struct B {
virtual void f();
virtual void f() volatile const;
};
struct D : B {
virtual void f() override;
virtual void f() override final const volatile; // expected-error {{'const' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'volatile' qualifier may not appear after the virtual specifier 'final'}}
};
struct B2 {
virtual void f() &;
virtual void f() volatile const &&;
};
struct D2 : B2 {
virtual void f() override &; // expected-error {{'&' qualifier may not appear after the virtual specifier 'override'}}
virtual void f() override final const volatile &&; // expected-error {{'const' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'volatile' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'&&' qualifier may not appear after the virtual specifier 'final'}}
};
}
|
