diff options
Diffstat (limited to 'clang/test/CXX/temp/temp.res')
10 files changed, 295 insertions, 0 deletions
diff --git a/clang/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp b/clang/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp new file mode 100644 index 0000000..75580d2 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// XFAIL: * + +// Note: we fail this test because we perform template instantiation +// at the end of the translation unit, so argument-dependent lookup +// finds functions that occur after the point of instantiation. Note +// that GCC fails this test; EDG passes the test in strict mode, but +// not in relaxed mode. +namespace N { + struct A { }; + struct B : public A { }; + + int& f0(A&); +} + +template<typename T, typename Result> +struct X0 { + void test_f0(T t) { + Result r = f0(t); + }; +}; + +void test_f0() { + X0<N::A, int&> xA; + xA.test_f0(N::A()); + X0<N::B, int&> xB; + xB.test_f0(N::B()); +} + +namespace N { + char& f0(B&); +} diff --git a/clang/test/CXX/temp/temp.res/temp.dep/p3.cpp b/clang/test/CXX/temp/temp.res/temp.dep/p3.cpp new file mode 100644 index 0000000..c41a4c6 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.dep/p3.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A0 { + struct K { }; +}; + +template <typename T> struct B0: A0 { + static void f() { + K k; + } +}; + +namespace E1 { + typedef double A; + + template<class T> class B { + typedef int A; + }; + + template<class T> + struct X : B<T> { + A* blarg(double *dp) { + return dp; + } + }; +} + +namespace E2 { + struct A { + struct B; + int *a; + int Y; + }; + + int a; + template<class T> struct Y : T { + struct B { /* ... */ }; + B b; + void f(int i) { a = i; } + Y* p; + }; + + Y<A> ya; +} diff --git a/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2-0x.cpp b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2-0x.cpp new file mode 100644 index 0000000..0aba402 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2-0x.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s + +template<int n> struct S; + +template<int n> struct T { + T() { + // An identifier is value-dependent if it is: + // - a name declared with a dependent type + S<n> s; + S<s> check1; // ok, s is value-dependent + // - the name of a non-type template parameter + typename S<n>::T check2; // ok, n is value-dependent + // - a constant with literal type and is initialized with an expression + // that is value-dependent. + const int k = n; + typename S<k>::T check3a; // ok, u is value-dependent + + constexpr const int *p = &k; + typename S<*p>::T check3b; // ok, p is value-dependent + + // (missing from the standard) + // - a reference and is initialized with an expression that is + // value-dependent. + const int &i = k; + typename S<i>::T check4; // ok, i is value-dependent + } +}; diff --git a/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2.cpp b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2.cpp new file mode 100644 index 0000000..68a41c7 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -std=c++98 -verify %s + +template<int n> struct S; + +template<int n> struct T { + T() { + // An identifier is value-dependent if it is: + // - a name declared with a dependent type + S<n> s; + S<s> check1; // ok, s is value-dependent + // - the name of a non-type template parameter + typename S<n>::T check2; // ok, n is value-dependent + // - a constant with literal type and is initialized with an expression + // that is value-dependent. + const int k = n; + typename S<k>::T check3; // ok, u is value-dependent + + const int &i = k; + typename S<i>::T check4; // expected-error {{not an integral constant expression}} expected-error {{qualified name}} + } +}; diff --git a/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p1.cpp b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p1.cpp new file mode 100644 index 0000000..81b070f --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p1.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// Examples from CWG1056. +namespace Example1 { + template<class T> struct A; + template<class T> using B = A<T>; + + template<class T> struct A { + struct C {}; + B<T>::C bc; // ok, B<T> is the current instantiation. + }; + + template<class T> struct A<A<T>> { + struct C {}; + B<B<T>>::C bc; // ok, B<B<T>> is the current instantiation. + }; + + template<class T> struct A<A<A<T>>> { + struct C {}; + B<B<T>>::C bc; // expected-error {{missing 'typename'}} + }; +} + +namespace Example2 { + template<class T> struct A { + void g(); + }; + template<class T> using B = A<T>; + template<class T> void B<T>::g() {} // ok. +} diff --git a/clang/test/CXX/temp/temp.res/temp.local/p1.cpp b/clang/test/CXX/temp/temp.res/temp.local/p1.cpp new file mode 100644 index 0000000..1ad4464 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.local/p1.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// C++0x [temp.local]p1: +// Like normal (non-template) classes, class templates have an +// injected-class-name (Clause 9). The injected-class-name can be used with +// or without a template-argument-list. When it is used without +// a template-argument-list, it is equivalent to the injected-class-name +// followed by the template-parameters of the class template enclosed in <>. + +template <typename T> struct X0 { + X0(); + ~X0(); + X0 f(const X0&); +}; + +// Test non-type template parameters. +template <int N1, const int& N2, const int* N3> struct X1 { + X1(); + ~X1(); + X1 f(const X1& x1a) { X1 x1b(x1a); return x1b; } +}; + +// When it is used with a template-argument-list, it refers to the specified +// class template specialization, which could be the current specialization +// or another specialization. +// FIXME: Test this clause. + +int i = 42; +void test() { + X0<int> x0; (void)x0; + X1<42, i, &i> x1; (void)x1; +} diff --git a/clang/test/CXX/temp/temp.res/temp.local/p3.cpp b/clang/test/CXX/temp/temp.res/temp.local/p3.cpp new file mode 100644 index 0000000..54da885 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.local/p3.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -verify %s + +template <class T> struct Base { // expected-note 4 {{member found by ambiguous name lookup}} + static void f(); +}; + +struct X0 { }; + +template <class T> struct Derived: Base<int>, Base<char> { + typename Derived::Base b; // expected-error{{member 'Base' found in multiple base classes of different types}} + typename Derived::Base<double> d; // OK + + void g(X0 *t) { + t->Derived::Base<T>::f(); + t->Base<T>::f(); + t->Base::f(); // expected-error{{member 'Base' found in multiple base classes of different types}} \ + // expected-error{{no member named 'f' in 'X0'}} \ + // expected-error{{expected a class or namespace}} + } +}; + +namespace PR6717 { + template <typename T> + class WebVector { + } // expected-error {{expected ';' after class}} + + WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \ + expected-error{{requires a type specifier}} + + template <typename C> + WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}} +} diff --git a/clang/test/CXX/temp/temp.res/temp.local/p7.cpp b/clang/test/CXX/temp/temp.res/temp.local/p7.cpp new file mode 100644 index 0000000..bd05e75 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.local/p7.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<class T> struct A { + int B; + int f(); +}; + +template<class B> int A<B>::f() { + return B; +} diff --git a/clang/test/CXX/temp/temp.res/temp.local/p8.cpp b/clang/test/CXX/temp/temp.res/temp.local/p8.cpp new file mode 100644 index 0000000..5d9d509 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.local/p8.cpp @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace N { + enum { C }; + template<class T> class B { + void f(T); + }; +} + +template<class C> void N::B<C>::f(C) { + C b; +} + +namespace N { + enum { D }; + namespace M { + enum { C , D }; + template<typename C> class X { + template<typename U> void f(C, U); + + template<typename D> void g(C, D) { + C c; + D d; + } + }; + + struct Y { + template<typename U> void f(U); + }; + } + + struct Y { + template<typename D> void f(D); + }; +} + +template<typename C> +template<typename D> +void N::M::X<C>::f(C, D) { + C c; + D d; +} + +template<typename C> +void N::M::Y::f(C) { + C c; +} + +template<typename D> +void N::Y::f(D) { + D d; +} + diff --git a/clang/test/CXX/temp/temp.res/temp.local/p9.cpp b/clang/test/CXX/temp/temp.res/temp.local/p9.cpp new file mode 100644 index 0000000..9ca8d88 --- /dev/null +++ b/clang/test/CXX/temp/temp.res/temp.local/p9.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A { + struct B { void f(); }; + int a; + int Y; +}; + +template<class B, class a> struct X : A { + B b; // A's B + a c; // expected-error{{unknown type name 'a'}} + + void g() { + b.g(); // expected-error{{no member named 'g' in 'A::B'}} + } +}; |