| // RUN: %clang_cc1 -verify -fsyntax-only -std=c++11 -Wshadow-all %s |
| |
| namespace { |
| int i; // expected-note {{previous declaration is here}} |
| } |
| |
| namespace one { |
| namespace two { |
| int j; // expected-note {{previous declaration is here}} |
| typedef int jj; // expected-note 2 {{previous declaration is here}} |
| using jjj=int; // expected-note 2 {{previous declaration is here}} |
| } |
| } |
| |
| namespace xx { |
| int m; |
| typedef int mm; |
| using mmm=int; |
| |
| } |
| namespace yy { |
| int m; |
| typedef char mm; |
| using mmm=char; |
| } |
| |
| using namespace one::two; |
| using namespace xx; |
| using namespace yy; |
| |
| void foo() { |
| int i; // expected-warning {{declaration shadows a variable in namespace '(anonymous)'}} |
| int j; // expected-warning {{declaration shadows a variable in namespace 'one::two'}} |
| int m; |
| int mm; |
| int mmm; |
| } |
| |
| class A { |
| static int data; // expected-note 1 {{previous declaration}} |
| // expected-note@+1 1 {{previous declaration}} |
| int field; |
| int f1, f2, f3, f4; // expected-note 8 {{previous declaration is here}} |
| |
| typedef int a1; // expected-note 2 {{previous declaration}} |
| using a2=int; // expected-note 2 {{previous declaration}} |
| |
| // The initialization is safe, but the modifications are not. |
| A(int f1, int f2, int f3, int f4) // expected-note-re 4 {{variable 'f{{[0-4]}}' is declared here}} |
| : f1(f1) { |
| f1 = 3; // expected-warning {{modifying constructor parameter 'f1' that shadows a field of 'A'}} |
| f1 = 4; // one warning per shadow |
| f2++; // expected-warning {{modifying constructor parameter 'f2' that shadows a field of 'A'}} |
| --f3; // expected-warning {{modifying constructor parameter 'f3' that shadows a field of 'A'}} |
| f4 += 2; // expected-warning {{modifying constructor parameter 'f4' that shadows a field of 'A'}} |
| } |
| |
| // The initialization is safe, but the modifications are not. |
| // expected-warning-re@+1 4 {{constructor parameter 'f{{[0-4]}}' shadows the field 'f{{[0-9]}}' of 'A'}} |
| A(int f1, int f2, int f3, int f4, double overload_dummy) {} |
| |
| void test() {
|
| char *field; // expected-warning {{declaration shadows a field of 'A'}}
|
| char *data; // expected-warning {{declaration shadows a static data member of 'A'}}
|
| char *a1; // no warning |
| char *a2; // no warning
|
| char *jj; // no warning
|
| char *jjj; // no warning
|
| } |
| |
| void test2() { |
| typedef char field; // no warning |
| typedef char data; // no warning |
| typedef char a1; // expected-warning {{declaration shadows a typedef in 'A'}} |
| typedef char a2; // expected-warning {{declaration shadows a type alias in 'A'}} |
| typedef char jj; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}} |
| typedef char jjj; // expected-warning {{declaration shadows a type alias in namespace 'one::two'}} |
| } |
| |
| void test3() { |
| using field=char; // no warning |
| using data=char; // no warning |
| using a1=char; // expected-warning {{declaration shadows a typedef in 'A'}} |
| using a2=char; // expected-warning {{declaration shadows a type alias in 'A'}} |
| using jj=char; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}} |
| using jjj=char; // expected-warning {{declaration shadows a type alias in namespace 'one::two'}} |
| } |
| }; |
| |
| struct path { |
| using value_type = char; |
| typedef char value_type2; |
| struct iterator { |
| using value_type = path; // no warning |
| typedef path value_type2; // no warning |
| }; |
| }; |
| |
| |
| // TODO: this should warn, <rdar://problem/5018057> |
| class B : A { |
| int data; |
| static int field; |
| }; |
| |
| // rdar://8900456 |
| namespace rdar8900456 { |
| struct Foo { |
| static void Baz(); |
| static void Baz1(); |
| static void Baz2(); |
| private: |
| int Bar; |
| }; |
| |
| void Foo::Baz() { |
| double Bar = 12; // Don't warn. |
| } |
| |
| void Foo::Baz1() { |
| typedef int Bar; // Don't warn. |
| } |
| |
| void Foo::Baz2() { |
| using Bar=int; // Don't warn. |
| } |
| } |
| |
| // http://llvm.org/PR9160 |
| namespace PR9160 { |
| struct V { |
| V(int); |
| }; |
| struct S { |
| V v; |
| static void m() { |
| if (1) { |
| V v(0); |
| } |
| } |
| }; |
| } |
| |
| extern int bob; // expected-note 1 {{previous declaration is here}} |
| typedef int bob1; // expected-note 2 {{previous declaration is here}} |
| using bob2=int; // expected-note 2 {{previous declaration is here}} |
| |
| // rdar://8883302 |
| void rdar8883302() { |
| extern int bob; // don't warn for shadowing. |
| } |
| |
| void test8() { |
| int bob; // expected-warning {{declaration shadows a variable in the global namespace}} |
| int bob1; //no warning |
| int bob2; // no warning |
| } |
| |
| void test9() { |
| typedef int bob; // no warning |
| typedef int bob1; // expected-warning {{declaration shadows a typedef in the global namespace}} |
| typedef int bob2; // expected-warning {{declaration shadows a type alias in the global namespace}} |
| } |
| |
| void test10() { |
| using bob=int; // no warning |
| using bob1=int; // expected-warning {{declaration shadows a typedef in the global namespace}} |
| using bob2=int; // expected-warning {{declaration shadows a type alias in the global namespace}} |
| } |
| |
| namespace rdar29067894 { |
| |
| void avoidWarningWhenRedefining(int b) { // expected-note {{previous definition is here}} |
| int a = 0; // expected-note {{previous definition is here}} |
| int a = 1; // expected-error {{redefinition of 'a'}} |
| int b = 2; // expected-error {{redefinition of 'b'}} |
| |
| using c=char; // expected-note {{previous definition is here}} |
| using c=int; // expected-error {{type alias redefinition with different types ('int' vs 'char')}} |
| |
| typedef char d; // expected-note {{previous definition is here}} |
| typedef int d; // expected-error {{typedef redefinition with different types ('int' vs 'char')}} |
| |
| using e=char; // expected-note {{previous definition is here}} |
| typedef int e; // expected-error {{type alias redefinition with different types ('int' vs 'char')}} |
| |
| int f; // expected-note {{previous definition is here}} |
| using f=int; // expected-error {{redefinition of 'f'}} |
| |
| using g=int; // expected-note {{previous definition is here}} |
| int g; // expected-error {{redefinition of 'g'}} |
| |
| typedef int h; // expected-note {{previous definition is here}} |
| int h; // expected-error {{redefinition of 'h'}} |
| |
| int k; // expected-note {{previous definition is here}} |
| typedef int k; // expected-error {{redefinition of 'k'}} |
| |
| using l=char; // no warning or error.
|
| using l=char; // no warning or error.
|
| typedef char l; // no warning or error.
|
| |
| typedef char n; // no warning or error. |
| typedef char n; // no warning or error. |
| using n=char; // no warning or error.
|
| }
|
| |
| } |
| |
| extern "C" { |
| typedef int externC; // expected-note {{previous declaration is here}} |
| } |
| void handleLinkageSpec() { |
| typedef void externC; // expected-warning {{declaration shadows a typedef in the global namespace}} |
| } |
| |
| namespace PR33947 { |
| void f(int a) { |
| struct A { |
| void g(int a) {} |
| A() { int a; } |
| };
|
| }
|
| }
|
|
|
| namespace PR34120 {
|
| struct A {
|
| int B; // expected-note 2 {{declared here}}
|
| };
|
|
|
| class C : public A {
|
| void D(int B) {} // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
|
| void E() {
|
| extern void f(int B); // Ok
|
| }
|
| void F(int B); // Ok, declaration; not definition.
|
| void G(int B);
|
| };
|
|
|
| void C::G(int B) { // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
|
| }
|
|
|
| class Private {
|
| int B;
|
| };
|
| class Derived : Private {
|
| void D(int B) {} // Ok
|
| };
|
|
|
| struct Static {
|
| static int B;
|
| };
|
|
|
| struct Derived2 : Static {
|
| void D(int B) {}
|
| };
|
| }
|
| |
| int PR24718; |
| enum class X { PR24718 }; // Ok, not shadowing |
| |
| struct PR24718_1; |
| struct PR24718_2 { |
| enum { |
| PR24718_1 // Does not shadow a type. |
| }; |
| }; |