Cross Reference: /external/clang/test/CXX/drs/dr3xx.cpp

Lines Matching defs:typename
6   template<typename R, typename A> void f(R (&)(A)) {}
14   template<typename T> void operator+(T, T);
26   template<typename T> void f() {
27     typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
37   template<typename T> class operator&<T*> {}; // expected-error +{{}}
38   template<typename T> class T::operator& {}; // expected-error +{{}}
39   template<typename T> class S::operator&<T*> {}; // expected-error +{{}}
104   template<typename T> struct X {};
114   template<typename> struct Nested {
115     template<typename> struct Nested {};
126     template<typename T> using T1 = Y;
128   template<typename T> using T2 = Y;
134     template<typename T> using T2 = T;
145     template<typename A> struct R {};
147   template<typename A> using R = Q::R<int>;
203   template<typename T> struct A {
204     template<typename U> struct B {};
206   template<typename T> struct C : public A<T>::template B<T> {
250   template<typename> struct X {};
295   template<typename T> void g(T t) { f(t); }
299     template<typename> struct I { friend bool operator==(const I&, const I&); };
307     template<typename T> operator T&();
343   template<typename> struct C { A a; }; // expected-error {{incomplete}}
349   template<typename T> struct A : B {
382   template<typename T> void f() {
424   template<typename T> void f(T (*)[1]);
425   template<typename T> int &f(...);
462   template<typename T> A<sizeof(f(T()))> make_A();
502   template<typename T> struct A {
503     template<typename U> struct B {};
506   template<typename T> struct C : public A<T>::B<T> { // expected-error {{use 'template'}}
524   template <class T> void f(T t) { typename T::X x; } // expected-error {{refers to non-type member 'X'}}
581       template<typename R, typename A> void foo(E, R (*)(A)); // expected-note 2{{couldn't infer template argument 'R'}}
584     template<typename T> void arg(T);
585     template<typename T> int arg(T) = delete; // expected-note {{here}} expected-error 0-1{{extension}}
628     template<typename T> void h1(T = 0); // expected-note {{couldn't infer}}
629     template<typename T> void h2(T, T = 0);
637     template<typename T> int tmpl(T);
638     template<typename R, typename A> void i1(R (*)(A)); // expected-note 3{{couldn't infer}}
639     template<typename R, typename A> void i2(R, A, R (*)(A)); // expected-note {{not viable}}
658   template<typename T> struct is_int;
662     template<typename T> int f(T (*p)(T)) { is_int<T>(); }
669     template<typename T> int f(T, T (*p)(T)) { is_int<T>(); }
752   template<typename T> struct A {
755   template<typename T> void A<T>::f() {} // expected-error {{does not match}}
758     template<typename T> void f();
760   template<typename T> void B::f() const {} // expected-error {{does not match}}
829   template<typename T, T> struct S {}; // expected-note {{here}}
830   template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
831   //template<typename T> int g(S<T, (T())> *); // FIXME: crashes clang
832   template<typename T> int g(S<T, true ? T() : T()> *); // expected-note {{cannot have type 'dr368::X'}}
841     template<typename T> struct X {
845     template<typename T> struct Y {};
849     template<typename T,
850              template<typename> class T1,
851              template<typename> class T2> struct Z1 :
853       T2<typename T1<T>::Type> {}; // expected-error {{protected}}
855     template<typename T,
856              template<typename> class T1,
857              template<typename> class T2> struct Z2 :
858       T2<typename T1<T>::Type>, // expected-error {{protected}}
870     template<typename T> struct A {
871       typename T::Type t; // expected-error {{private}}
882     template<typename T> struct B {};
883     template<typename U> struct C : U, B<typename U::N> {}; // expected-error {{protected}}
884     template<typename U> struct D : B<typename U::N>, U {}; // expected-error {{protected}}
921     template<typename T> void f();
922     template<typename T> struct A { void f(); };
967   typename A::T t;
968   typename dr382::A a;
973   typename A b; // expected-error {{expected a qualified name}}
986     template<typename T> struct Base {};
987     template<typename T> struct X {
997     template<typename T> int *operator+(T, unsigned);
1020     template<typename T> class number {
1033     template <typename T> class number {
1056   template<typename> struct T {};
1162   template<typename T>
1168   template<typename T> A<T>::~A() { T::error; } // expected-error {{cannot be used prior to}}
1169   template<typename T> void A<T>::f() { T::error; } // ok, not odr-used
1191   template<typename T>
1204     template <typename T, int N>(&operator T())[N]; // expected-error {{must use a typedef}}
1205     template <typename T, int N> operator(T (&)[N])(); // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error +{{}}
1206     template <typename T> operator T *() const { return 0; }
1207     template <typename T, typename U> operator T U::*() const { return 0; }
1208     template <typename T, typename U> operator T (U::*)()() const { return 0; } // expected-error +{{}}
1217     operator typename ptr_mem_fun_t<T, U>::type() const { // expected-note {{couldn't infer}}
1223   template <typename T> using id = T; // expected-error 0-1{{extension}}
1226     template <typename T, int N> operator id<T[N]> &();
1227     template <typename T, typename U> operator id<T (U::*)()>() const;
1256     template <typename T> void f(X<T::I> *) {}
1257     template <typename T> void f(X<T::J> *) {}
1264     template <class T> void f(typename T::Y *) {} // expected-note 2{{substitution failure}}