715ee079da
Diagnose the name of the class being shadowed by using declarations, and improve the diagnostics for the case where the name of the class is shadowed by a non-static data member in a class with constructors. In the latter case, we now always give the "member with the same name as its class" diagnostic regardless of the relative order of the member and the constructor, rather than giving an inscrutible diagnostic if the constructor appears second. llvm-svn: 335182
117 lines
3.9 KiB
C++
117 lines
3.9 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
|
|
|
|
// If T is the name of a class, then each of the following shall have
|
|
// a name different from T:
|
|
|
|
// - every static data member of class T;
|
|
struct X0 {
|
|
static int X0; // expected-error{{member 'X0' has the same name as its class}}
|
|
};
|
|
|
|
// - every member function of class T
|
|
struct Xa {
|
|
int Xa() {} // expected-error{{constructor cannot have a return type}}
|
|
};
|
|
|
|
// - every member of class T that is itself a type;
|
|
struct X1 {
|
|
enum X1 { }; // expected-error{{member 'X1' has the same name as its class}}
|
|
};
|
|
|
|
struct X1a {
|
|
struct X1a; // expected-error{{member 'X1a' has the same name as its class}}
|
|
};
|
|
|
|
struct X2 {
|
|
typedef int X2; // expected-error{{member 'X2' has the same name as its class}}
|
|
};
|
|
|
|
struct X2a {
|
|
using X2a = int; // expected-error{{member 'X2a' has the same name as its class}}
|
|
};
|
|
|
|
// - every member template of class T
|
|
|
|
struct X2b {
|
|
template<typename T> struct X2b; // expected-error{{member 'X2b' has the same name as its class}}
|
|
};
|
|
struct X2c {
|
|
template<typename T> void X2c(); // expected-error{{constructor cannot have a return type}}
|
|
};
|
|
struct X2d {
|
|
template<typename T> static int X2d; // expected-error{{member 'X2d' has the same name as its class}}
|
|
};
|
|
struct X2e {
|
|
template<typename T> using X2e = int; // expected-error{{member 'X2e' has the same name as its class}}
|
|
};
|
|
|
|
// - every enumerator of every member of class T that is an unscoped enumerated type; and
|
|
struct X3 {
|
|
enum E {
|
|
X3 // expected-error{{member 'X3' has the same name as its class}}
|
|
};
|
|
};
|
|
struct X3a {
|
|
enum class E {
|
|
X3a // ok
|
|
};
|
|
};
|
|
|
|
// - every member of every anonymous union that is a member of class T.
|
|
struct X4 { // expected-note{{previous}}
|
|
union {
|
|
int X;
|
|
union {
|
|
float Y;
|
|
unsigned X4; // expected-error{{redeclares 'X4'}}
|
|
};
|
|
};
|
|
};
|
|
|
|
// This includes such things inherited from base classes.
|
|
struct B {
|
|
static int D0;
|
|
int Da() {};
|
|
enum D1 {};
|
|
struct D1a;
|
|
typedef int D2;
|
|
using D2a = int;
|
|
template<typename T> struct D2b;
|
|
template<typename T> void D2c();
|
|
template<typename T> static int D2d;
|
|
template<typename T> using D2e = int;
|
|
union { int D4; };
|
|
int Dtemplate;
|
|
int Dtemplate_with_ctors;
|
|
};
|
|
struct B2 { int Dtemplate(); };
|
|
|
|
struct D0 : B { using B::D0; }; // expected-error {{member 'D0' has the same name as its class}}
|
|
struct Da : B { using B::Da; }; // expected-error {{member 'Da' has the same name as its class}}
|
|
struct D1 : B { using B::D1; }; // expected-error {{member 'D1' has the same name as its class}}
|
|
struct D1a : B { using B::D1a; }; // expected-error {{member 'D1a' has the same name as its class}}
|
|
struct D2 : B { using B::D2; }; // expected-error {{member 'D2' has the same name as its class}}
|
|
struct D2a : B { using B::D2a; }; // expected-error {{member 'D2a' has the same name as its class}}
|
|
struct D2b : B { using B::D2b; }; // expected-error {{member 'D2b' has the same name as its class}}
|
|
struct D2c : B { using B::D2c; }; // expected-error {{member 'D2c' has the same name as its class}}
|
|
struct D2d : B { using B::D2d; }; // expected-error {{member 'D2d' has the same name as its class}}
|
|
struct D2e : B { using B::D2e; }; // expected-error {{member 'D2e' has the same name as its class}}
|
|
struct D4 : B { using B::D4; }; // expected-error {{member 'D4' has the same name as its class}}
|
|
|
|
template<typename B> struct Dtemplate : B {
|
|
using B::Dtemplate; // expected-error {{member 'Dtemplate' has the same name as its class}}
|
|
};
|
|
Dtemplate<B> ok;
|
|
Dtemplate<B2> error; // expected-note {{in instantiation of}}
|
|
|
|
template<typename B> struct Dtemplate_with_ctors : B {
|
|
Dtemplate_with_ctors();
|
|
using B::Dtemplate_with_ctors; // expected-error {{member 'Dtemplate_with_ctors' has the same name as its class}}
|
|
};
|
|
|
|
template<typename B> struct CtorDtorName : B {
|
|
using B::CtorDtorName; // expected-error {{member 'CtorDtorName' has the same name as its class}}
|
|
CtorDtorName();
|
|
~CtorDtorName(); // expected-error {{expected the class name after '~' to name a destructor}}
|
|
};
|