dependent-names.cpp [plain text]
typedef double A;
template<typename T> class B {
typedef int A;
};
template<typename T> struct X : B<T> {
static A a;
};
int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1];
template<class T> class Q;
template<class T> class R : Q<T> {T current;};
namespace test0 {
template <class T> class Base {
public:
void instance_foo();
static void static_foo();
class Inner {
public:
void instance_foo();
static void static_foo();
};
};
template <class T> class Derived1 : Base<T> {
public:
void test0() {
Base<T>::static_foo();
Base<T>::instance_foo();
}
void test1() {
Base<T>::Inner::static_foo();
Base<T>::Inner::instance_foo(); }
static void test2() {
Base<T>::static_foo();
Base<T>::instance_foo(); }
static void test3() {
Base<T>::Inner::static_foo();
Base<T>::Inner::instance_foo(); }
};
template <class T> class Derived2 : Base<T>::Inner {
public:
void test0() {
Base<T>::static_foo();
Base<T>::instance_foo(); }
void test1() {
Base<T>::Inner::static_foo();
Base<T>::Inner::instance_foo();
}
static void test2() {
Base<T>::static_foo();
Base<T>::instance_foo(); }
static void test3() {
Base<T>::Inner::static_foo();
Base<T>::Inner::instance_foo(); }
};
void test0() {
Derived1<int> d1;
d1.test0();
d1.test1(); d1.test2(); d1.test3();
Derived2<int> d2;
d2.test0(); d2.test1();
d2.test2(); d2.test3(); }
}
namespace test1 {
template <class T> struct Base {
void foo(T); };
template <class T> struct Derived : Base<T> {
void doFoo(T v) {
foo(v); }
};
template struct Derived<int>; }
namespace PR8966 {
template <class T>
class MyClassCore
{
};
template <class T>
class MyClass : public MyClassCore<T>
{
public:
enum {
N
};
static const char* array [N];
void f() {
MyClass<T>::InBase = 17;
}
};
template <class T>
const char* MyClass<T>::array [MyClass<T>::N] = { "A", "B", "C" };
}
namespace std {
inline namespace v1 {
template<typename T> struct basic_ostream;
}
namespace inner {
template<typename T> struct vector {};
}
using inner::vector;
template<typename T, typename U> struct pair {};
typedef basic_ostream<char> ostream;
extern ostream cout;
std::ostream &operator<<(std::ostream &out, const char *);
}
namespace PR10053 {
template<typename T> struct A {
T t;
A() {
f(t); }
};
void f(int&);
A<int> a;
namespace N {
namespace M {
template<typename T> int g(T t) {
f(t); };
}
void f(char&); }
void f(char&);
int k = N::M::g<char>(0);;
namespace O {
void f(char&);
template<typename T> struct C {
static const int n = f(T()); };
}
int f(double); O::C<double> c;
namespace my_file {
template <typename T> T Squared(T x) {
return Multiply(x, x); }
int Multiply(int x, int y) { return x * y;
}
int main() {
Squared(5); }
}
namespace my_file2 {
template<typename T>
void Dump(const T& value) {
std::cout << value << "\n"; }
namespace ns {
struct Data {};
}
std::ostream& operator<<(std::ostream& out, ns::Data data) { return out << "Some data";
}
void Use() {
Dump(ns::Data()); }
}
namespace my_file2_a {
template<typename T>
void Dump(const T &value) {
print(std::cout, value); }
namespace ns {
struct Data {};
}
namespace ns2 {
struct Data {};
}
std::ostream &print(std::ostream &out, int); std::ostream &print(std::ostream &out, ns::Data); std::ostream &print(std::ostream &out, std::vector<ns2::Data>); std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>);
void Use() {
Dump(0); Dump(ns::Data()); Dump(std::vector<ns2::Data>()); Dump(std::pair<ns::Data, ns2::Data>()); }
}
namespace unary {
template<typename T>
T Negate(const T& value) {
return !value; }
namespace ns {
struct Data {};
}
ns::Data operator!(ns::Data);
void Use() {
Negate(ns::Data()); }
}
}
namespace PR10187 {
namespace A {
template<typename T>
struct S {
void f() {
for (auto &a : e)
__range(a); }
int e[10];
};
void g() {
S<int>().f(); }
}
namespace B {
template<typename T> void g(); template<typename T> void f() {
g<int>(T()); }
namespace {
struct S {};
}
void g(S);
template void f<S>(); }
}
namespace rdar11242625 {
template <typename T>
struct Main {
struct default_names {
typedef int id;
};
template <typename T2 = typename default_names::id>
struct TS {
T2 q;
};
};
struct Sub : public Main<int> {
TS<> ff;
};
int arr[sizeof(Sub)];
}
namespace PR11421 {
template < unsigned > struct X {
static const unsigned dimension = 3;
template<unsigned dim=dimension>
struct Y: Y<dim> { }; };
typedef X<3> X3;
X3::Y<>::iterator it; }
namespace rdar12629723 {
template<class T>
struct X {
struct C : public C { };
struct B;
struct A : public B { virtual void foo() { }
};
struct B;
struct D : T::foo { };
struct E : D { };
};
template<class T>
struct X<T>::B : public A { virtual void foo() { }
};
}