2009-03-24 10:24:46 +08:00
|
|
|
// RUN: clang-cc -fsyntax-only -verify %s
|
2009-03-03 12:44:36 +08:00
|
|
|
template<typename T, typename U = int> struct A; // expected-note 2{{template is declared here}}
|
2009-02-18 07:15:12 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<double, double>; // expected-note{{forward declaration}}
|
2009-02-18 07:15:12 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<float, float> { // expected-note{{previous definition}}
|
2009-02-18 07:15:12 +08:00
|
|
|
int x;
|
|
|
|
};
|
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<float> { // expected-note{{previous definition}}
|
2009-02-18 07:15:12 +08:00
|
|
|
int y;
|
|
|
|
};
|
|
|
|
|
|
|
|
int test_specs(A<float, float> *a1, A<float, int> *a2) {
|
|
|
|
return a1->x + a2->y;
|
|
|
|
}
|
|
|
|
|
|
|
|
int test_incomplete_specs(A<double, double> *a1,
|
2009-03-03 12:44:36 +08:00
|
|
|
A<double> *a2)
|
2009-02-18 07:15:12 +08:00
|
|
|
{
|
|
|
|
(void)a1->x; // expected-error{{incomplete definition of type 'A<double, double>'}}
|
2009-03-11 02:33:27 +08:00
|
|
|
(void)a2->x; // expected-error{{implicit instantiation of undefined template 'struct A<double, int>'}}
|
2009-02-18 07:15:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef float FLOAT;
|
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<float, FLOAT>;
|
2009-02-18 07:15:12 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}}
|
2009-02-18 07:15:12 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct A<float, int> { }; // expected-error{{redefinition}}
|
2009-02-19 08:52:42 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template<typename T, typename U = int> struct X;
|
2009-02-19 08:52:42 +08:00
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
template <> struct X<int, int> { int foo(); }; // #1
|
|
|
|
template <> struct X<float> { int bar(); }; // #2
|
2009-02-19 08:52:42 +08:00
|
|
|
|
|
|
|
typedef int int_type;
|
|
|
|
void testme(X<int_type> *x1, X<float, int> *x2) {
|
2009-02-26 08:02:51 +08:00
|
|
|
(void)x1->foo(); // okay: refers to #1
|
|
|
|
(void)x2->bar(); // okay: refers to #2
|
2009-02-19 08:52:42 +08:00
|
|
|
}
|
Implement parsing of nested-name-specifiers that involve template-ids, e.g.,
std::vector<int>::allocator_type
When we parse a template-id that names a type, it will become either a
template-id annotation (which is a parsed representation of a
template-id that has not yet been through semantic analysis) or a
typename annotation (where semantic analysis has resolved the
template-id to an actual type), depending on the context. We only
produce a type in contexts where we know that we only need type
information, e.g., in a type specifier. Otherwise, we create a
template-id annotation that can later be "upgraded" by transforming it
into a typename annotation when the parser needs a type. This occurs,
for example, when we've parsed "std::vector<int>" above and then see
the '::' after it. However, it means that when writing something like
this:
template<> class Outer::Inner<int> { ... };
We have two tokens to represent Outer::Inner<int>: one token for the
nested name specifier Outer::, and one template-id annotation token
for Inner<int>, which will be passed to semantic analysis to define
the class template specialization.
Most of the churn in the template tests in this patch come from an
improvement in our error recovery from ill-formed template-ids.
llvm-svn: 65467
2009-02-26 03:37:18 +08:00
|
|
|
|
2009-02-26 08:02:51 +08:00
|
|
|
// Make sure specializations are proper classes.
|
|
|
|
template<>
|
|
|
|
struct A<char> {
|
|
|
|
A();
|
|
|
|
};
|
|
|
|
|
|
|
|
A<char>::A() { }
|
|
|
|
|
2009-08-27 02:54:58 +08:00
|
|
|
// Make sure we can see specializations defined before the primary template.
|
|
|
|
namespace N{
|
|
|
|
template<typename T> struct A0;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace N {
|
|
|
|
template<>
|
|
|
|
struct A0<void> {
|
|
|
|
typedef void* pointer;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace N {
|
|
|
|
template<typename T>
|
|
|
|
struct A0 {
|
|
|
|
void foo(A0<void>::pointer p = 0);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-02-26 08:02:51 +08:00
|
|
|
// Diagnose specialization errors
|
2009-02-26 06:02:03 +08:00
|
|
|
struct A<double> { }; // expected-error{{template specialization requires 'template<>'}}
|
|
|
|
|
|
|
|
template<> struct ::A<double>;
|
|
|
|
|
|
|
|
namespace N {
|
|
|
|
template<typename T> struct B; // expected-note 2{{template is declared here}}
|
|
|
|
|
2009-02-26 06:18:32 +08:00
|
|
|
template<> struct ::N::B<char>; // okay
|
2009-02-26 06:02:03 +08:00
|
|
|
template<> struct ::N::B<short>; // okay
|
|
|
|
template<> struct ::N::B<int>; // okay
|
2009-02-26 06:18:32 +08:00
|
|
|
|
|
|
|
int f(int);
|
2009-02-26 06:02:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template<> struct N::B<int> { }; // okay
|
|
|
|
|
|
|
|
template<> struct N::B<float> { }; // expected-error{{class template specialization of 'B' not in namespace 'N'}}
|
|
|
|
|
|
|
|
namespace M {
|
|
|
|
template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}}
|
|
|
|
|
|
|
|
template<> struct ::A<long double>; // expected-error{{class template specialization of 'A' must occur in the global scope}}
|
|
|
|
}
|
2009-02-26 06:18:32 +08:00
|
|
|
|
|
|
|
template<> struct N::B<char> {
|
|
|
|
int testf(int x) { return f(x); }
|
|
|
|
};
|
2009-02-26 08:02:51 +08:00
|
|
|
|