Clang Project

clang_source_code/test/SemaCXX/decl-expr-ambiguity.cpp
1// RUN: %clang_cc1 -Wno-int-to-pointer-cast -fsyntax-only -verify -pedantic-errors %s
2// RUN: %clang_cc1 -Wno-int-to-pointer-cast -fsyntax-only -verify -pedantic-errors -std=gnu++98 %s
3// RUN: %clang_cc1 -Wno-int-to-pointer-cast -fsyntax-only -verify -pedantic-errors -std=gnu++11 %s
4// RUN: %clang_cc1 -Wno-int-to-pointer-cast -fsyntax-only -verify -pedantic-errors -x objective-c++ %s
5
6void f() {
7  int a;
8  struct S { int m; };
9  typedef S *T;
10
11  // Expressions.
12  T(a)->m = 7;
13  int(a)++; // expected-error {{assignment to cast is illegal}}
14  __extension__ int(a)++; // expected-error {{assignment to cast is illegal}}
15  __typeof(int)(a,5)<<a; // expected-error {{excess elements in scalar initializer}}
16  void(a), ++a;
17  if (int(a)+1) {}
18  for (int(a)+1;;) {} // expected-warning {{expression result unused}}
19  a = sizeof(int()+1);
20  a = sizeof(int(1));
21  typeof(int()+1) a2; // expected-error {{extension used}}
22  (int(1)); // expected-warning {{expression result unused}}
23
24  // type-id
25  (int())1; // expected-error {{C-style cast from 'int' to 'int ()' is not allowed}}
26
27  // Declarations.
28  int fd(T(a)); // expected-warning {{disambiguated as a function declaration}} expected-note{{add a pair of parentheses}}
29  T(*d)(int(p)); // expected-note {{previous}}
30  typedef T td(int(p));
31  extern T tp(int(p));
32  T d3(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}}
33  T d3v(void);
34  typedef T d3t();
35  extern T f3();
36  __typeof(*T()) f4(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}}
37  typedef void *V;
38  __typeof(*V()) f5(); // expected-error {{ISO C++ does not allow indirection on operand of type 'V' (aka 'void *')}}
39  T multi1,
40    multi2(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}}
41  T(d)[5]; // expected-error {{redefinition of 'd'}}
42  typeof(int[])(f) = { 1, 2 }; // expected-error {{extension used}}
43  void(b)(int);
44  int(d2) __attribute__(());
45  if (int(a)=1) {}
46  int(d3(int()));
47}
48
49struct RAII {
50  RAII();
51  RAII(int);
52  ~RAII();
53};
54
55struct NotRAII {
56  NotRAII();
57  NotRAII(int);
58};
59
60void func();
61void func2(short);
62namespace N {
63  struct S;
64  int n;
65
66  void emptyParens() {
67    RAII raii(); // expected-warning {{function declaration}} expected-note {{remove parentheses to declare a variable}}
68    int a, b, c, d, e, // expected-note {{change this ',' to a ';' to call 'func'}}
69    func(); // expected-warning {{function declaration}} expected-note {{replace parentheses with an initializer}}
70
71    S s(); // expected-warning {{function declaration}}
72#if __cplusplus >= 201103L
73    // expected-note@-2 {{replace parentheses with an initializer to declare a variable}}
74#endif
75  }
76  void nonEmptyParens() {
77    int f = 0, // g = 0; expected-note {{change this ',' to a ';' to call 'func2'}}
78    func2(short(f)); // expected-warning {{function declaration}} expected-note {{add a pair of parentheses}}
79
80    RAII(n); // expected-warning {{parentheses were disambiguated as redundant parentheses around declaration of variable named 'n'}}
81    // expected-note@-1 {{add a variable name to declare a 'RAII' initialized with 'n'}}
82    // expected-note@-2 {{add enclosing parentheses to perform a function-style cast}}
83    // expected-note@-3 {{remove parentheses to silence this warning}}
84
85    RAII(undeclared1);
86#pragma clang diagnostic push
87#pragma clang diagnostic warning "-Wredundant-parens"
88    RAII(undeclared2); // expected-warning {{redundant parentheses surrounding declarator}}
89#pragma clang diagnostic pop
90
91    {
92      NotRAII(n); // expected-warning {{parentheses were disambiguated as redundant parentheses around declaration of variable named 'n'}}
93      // expected-note@-1 {{add enclosing parentheses to perform a function-style cast}}
94      // expected-note@-2 {{remove parentheses to silence this warning}}
95    }
96  }
97}
98
99class C { };
100void fn(int(C)) { } // void fn(int(*fp)(C c)) { } expected-note{{candidate function}}
101                    // not: void fn(int C);
102int g(C);
103
104void foo() {
105  fn(1); // expected-error {{no matching function}}
106  fn(g); // OK
107}
108
109namespace PR11874 {
110void foo(); // expected-note 3 {{class 'foo' is hidden by a non-type declaration of 'foo' here}}
111class foo {};
112class bar {
113  bar() {
114    const foo* f1 = 0; // expected-error {{must use 'class' tag to refer to type 'foo' in this scope}}
115    foo* f2 = 0; // expected-error {{must use 'class' tag to refer to type 'foo' in this scope}}
116    foo f3; // expected-error {{must use 'class' tag to refer to type 'foo' in this scope}}
117  }
118};
119
120int baz; // expected-note 2 {{class 'baz' is hidden by a non-type declaration of 'baz' here}}
121class baz {};
122void fizbin() {
123  const baz* b1 = 0; // expected-error {{must use 'class' tag to refer to type 'baz' in this scope}}
124  baz* b2; // expected-error {{use of undeclared identifier 'b2'}}
125  baz b3; // expected-error {{must use 'class' tag to refer to type 'baz' in this scope}}
126}
127}
128
129namespace TemporaryFromFunctionCall {
130  struct A {
131    A(int);
132  };
133  int f();
134  int g(int);
135  namespace N {
136    void x() {
137      // FIXME: For the first and second of these (but not the third), we
138      // should produce a vexing-parse warning.
139      A(f());
140      A(g(int()));
141      A(g(int));
142    }
143  }
144}
145
CodeThinker, Enjoy your reading code