forked from OSchip/llvm-project
171 lines
3.2 KiB
C++
171 lines
3.2 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
|
|
namespace N { struct X { }; };
|
|
|
|
namespace A = N;
|
|
|
|
int B; // expected-note {{previous definition is here}}
|
|
namespace B = N; // expected-error {{redefinition of 'B' as different kind of symbol}}
|
|
|
|
namespace C { } // expected-note {{previous definition is here}}
|
|
namespace C = N; // expected-error {{redefinition of 'C'}}
|
|
|
|
int i;
|
|
namespace D =
|
|
i; // expected-error {{expected namespace name}}
|
|
|
|
namespace E1 = N::
|
|
Foo; // expected-error {{expected namespace name}}
|
|
namespace E2 = N::
|
|
X; // expected-error {{expected namespace name}}
|
|
|
|
namespace F {
|
|
namespace A { namespace B { } } // expected-note {{candidate found by name lookup is 'F::A::B'}}
|
|
namespace B { } // expected-note {{candidate found by name lookup is 'F::B'}}
|
|
using namespace A;
|
|
namespace D = B; // expected-error {{reference to 'B' is ambiguous}}
|
|
}
|
|
|
|
namespace G {
|
|
namespace B = N;
|
|
}
|
|
|
|
namespace H {
|
|
namespace A1 { }
|
|
namespace A2 { }
|
|
|
|
// These all point to A1.
|
|
namespace B = A1;
|
|
namespace B = A1;
|
|
namespace C = B;
|
|
namespace B = C; // expected-note {{previously defined as an alias for 'A1'}}
|
|
|
|
namespace B = A2; // expected-error {{redefinition of 'B' as an alias for a different namespace}}
|
|
}
|
|
|
|
namespace I {
|
|
namespace A1 { int i; }
|
|
|
|
namespace A2 = A1;
|
|
}
|
|
|
|
int f() {
|
|
return I::A2::i;
|
|
}
|
|
|
|
namespace J {
|
|
namespace A {
|
|
namespace B { void func (); }
|
|
}
|
|
|
|
namespace C = A;
|
|
|
|
using namespace C::B;
|
|
|
|
void g() {
|
|
func();
|
|
}
|
|
}
|
|
|
|
namespace K {
|
|
namespace KA { void func(); }
|
|
|
|
void f() {
|
|
namespace KB = KA;
|
|
KB::func();
|
|
}
|
|
|
|
template <class T> void g() {
|
|
namespace KC = KA;
|
|
KC::func();
|
|
}
|
|
template void g<int>();
|
|
template void g<long>();
|
|
|
|
void h() {
|
|
KB::func(); // expected-error {{undeclared identifier 'KB'}}
|
|
KC::func(); // expected-error {{undeclared identifier 'KC'}}
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
class C1;
|
|
}
|
|
namespace {
|
|
class C1;
|
|
}
|
|
C1 *pc1 = 0;
|
|
|
|
namespace N {
|
|
namespace {
|
|
class C2;
|
|
}
|
|
}
|
|
namespace N {
|
|
namespace {
|
|
class C2;
|
|
}
|
|
}
|
|
N::C2 *pc2 = 0;
|
|
|
|
// PR6341
|
|
namespace A = N;
|
|
namespace N { }
|
|
namespace A = N;
|
|
|
|
A::X nx;
|
|
|
|
namespace PR7014 {
|
|
namespace X
|
|
{
|
|
namespace Y {}
|
|
}
|
|
|
|
using namespace X;
|
|
|
|
namespace Y = X::Y;
|
|
}
|
|
|
|
namespace PR25731 {
|
|
void f() {
|
|
namespace X = PR25731;
|
|
namespace X = PR25731;
|
|
X::f();
|
|
}
|
|
}
|
|
|
|
namespace MultipleUnambiguousLookupResults {
|
|
namespace A { int y; }
|
|
namespace B {
|
|
namespace X { int x; }
|
|
namespace Y = A;
|
|
namespace Z = A; // expected-note {{candidate}}
|
|
}
|
|
namespace C {
|
|
namespace X = B::X;
|
|
namespace Y = A;
|
|
namespace Z = X; // expected-note {{candidate}}
|
|
}
|
|
using namespace B;
|
|
using namespace C;
|
|
int x1 = X::x; // ok, unambiguous
|
|
int y1 = Y::y; // ok, unambiguous
|
|
int z1 = Z::x; // expected-error {{ambiguous}}
|
|
|
|
namespace X = C::X;
|
|
namespace Y = A;
|
|
int x2 = X::x; // ok, unambiguous
|
|
int y2 = Y::y; // ok, unambiguous
|
|
}
|
|
|
|
namespace RedeclOfNonNamespace {
|
|
int a; // expected-note {{previous}}
|
|
namespace X { int b; }
|
|
using X::b; // expected-note {{previous}}
|
|
namespace c {} // expected-note {{previous}}
|
|
|
|
namespace a = X; // expected-error {{different kind}}
|
|
namespace b = X; // expected-error {{different kind}}
|
|
namespace c = X; // expected-error-re {{redefinition of 'c'{{$}}}}
|
|
}
|