1// RUN: %clang_cc1 -verify -fsyntax-only -std=c++11 -pedantic-errors -triple x86_64-linux-gnu %s
2
3// Make sure we know these are legitimate commas and not typos for ';'.
4namespace Commas {
5  int a,
6  b [[ ]],
7  c alignas(double);
8}
9
10struct S {};
11enum E { e, };
12
13auto f() -> struct S {
14  return S();
15}
16auto g() -> enum E {
17  return E();
18}
19
20class ExtraSemiAfterMemFn {
21  // Due to a peculiarity in the C++11 grammar, a deleted or defaulted function
22  // is permitted to be followed by either one or two semicolons.
23  void f() = delete // expected-error {{expected ';' after delete}}
24  void g() = delete; // ok
25  void h() = delete;; // ok
26  void i() = delete;;; // expected-error {{extra ';' after member function definition}}
27};
28
29int *const const p = 0; // expected-error {{duplicate 'const' declaration specifier}}
30const const int *q = 0; // expected-error {{duplicate 'const' declaration specifier}}
31
32struct MultiCV {
33  void f() const const; // expected-error {{duplicate 'const' declaration specifier}}
34};
35
36static_assert(something, ""); // expected-error {{undeclared identifier}}
37
38// PR9903
39struct SS {
40  typedef void d() = default; // expected-error {{function definition declared 'typedef'}} expected-error {{only special member functions may be defaulted}}
41};
42
43using PR14855 = int S::; // expected-error {{expected ';' after alias declaration}}
44
45// Ensure that 'this' has a const-qualified type in a trailing return type for
46// a constexpr function.
47struct ConstexprTrailingReturn {
48  int n;
49  constexpr auto f() const -> decltype((n));
50};
51constexpr const int &ConstexprTrailingReturn::f() const { return n; }
52
53namespace TestIsValidAfterTypeSpecifier {
54struct s {} v;
55
56struct s
57thread_local tl;
58
59struct s
60&r0 = v;
61
62struct s
63&&r1 = s();
64
65struct s
66bitand r2 = v;
67
68struct s
69and r3 = s();
70
71enum E {};
72enum E
73[[]] e;
74
75}
76
77namespace PR5066 {
78  using T = int (*f)(); // expected-error {{type-id cannot have a name}}
79  template<typename T> using U = int (*f)(); // expected-error {{type-id cannot have a name}}
80  auto f() -> int (*f)(); // expected-error {{type-id cannot have a name}}
81  auto g = []() -> int (*f)() {}; // expected-error {{type-id cannot have a name}}
82}
83
84namespace FinalOverride {
85  struct Base {
86    virtual void *f();
87    virtual void *g();
88    virtual void *h();
89    virtual void *i();
90  };
91  struct Derived : Base {
92    virtual auto f() -> void *final;
93    virtual auto g() -> void *override;
94    virtual auto h() -> void *final override;
95    virtual auto i() -> void *override final;
96  };
97}
98
99namespace UsingDeclAttrs {
100  using T __attribute__((aligned(1))) = int;
101  using T [[gnu::aligned(1)]] = int;
102  static_assert(alignof(T) == 1, "");
103
104  using [[gnu::aligned(1)]] T = int; // expected-error {{an attribute list cannot appear here}}
105  using T = int [[gnu::aligned(1)]]; // expected-error {{'aligned' attribute cannot be applied to types}}
106}
107
108namespace DuplicateSpecifier {
109  constexpr constexpr int f(); // expected-warning {{duplicate 'constexpr' declaration specifier}}
110  constexpr int constexpr a = 0; // expected-warning {{duplicate 'constexpr' declaration specifier}}
111
112  struct A {
113    friend constexpr int constexpr friend f(); // expected-warning {{duplicate 'friend' declaration specifier}} \
114                                               // expected-warning {{duplicate 'constexpr' declaration specifier}}
115    friend struct A friend; // expected-warning {{duplicate 'friend'}} expected-error {{'friend' must appear first}}
116  };
117}
118
119struct Base { virtual void f() = 0; virtual void g() = 0; virtual void h() = 0; };
120struct MemberComponentOrder : Base {
121  void f() override __asm__("foobar") __attribute__(( )) {}
122  void g() __attribute__(( )) override;
123  void h() __attribute__(( )) override {}
124};
125