Clang Project

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