| /external/clang/test/SemaTemplate/ |
| instantiation-default-3.cpp | 4 template<typename T> struct A { };
6 template<typename T, typename U = A<T*> >
9 template<>
14 template<>
|
| missing-class-keyword-crash.cpp | 3 template <Foo> // expected-error{{unknown type name 'Foo'}} \
4 // expected-note{{template parameter is declared here}}
7 class Bar<G> blah_test; // expected-error{{template argument for non-type template parameter must be an expression}}
|
| ms-class-specialization-duplicate.cpp | 1 // RUN: %clang_cc1 -fms-compatibility -fdelayed-template-parsing -fsyntax-only -verify %s
3 template <typename T>
8 template class A<int>; // expected-note {{previous explicit instantiation is here}}
9 template class A<TInt>; // expected-warning {{duplicate explicit instantiation of 'A<int>' ignored as a Microsoft extension}}
|
| instantiate-deeply.cpp | 3 template<typename a> struct A {
4 template <typename b> struct B {
5 template <typename c> struct C {
6 template <typename d> struct D {
7 template <typename e> struct E {
25 template <typename T>
37 template class Foo<int>;
|
| deduction-crash.cpp | 8 template<a>
11 template<a>
12 template<int,typename T1,typename>
18 template<class>struct aaa
23 template<class>
32 template<class>
35 template<class,int=0>
38 template<int my>
41 template<class Event>
47 template<class Event
[all...] |
| partial-spec-instantiate.cpp | 4 template <class T> struct X {};
6 template <> struct X<char>
11 template <class T> struct X2 {};
13 template <class U>
23 template<typename T>
28 template<typename U>
31 template<typename U>
34 template<>
44 template<typename T, T N> struct X { };
45 template<bool C> struct X<bool, C>
[all...] |
| /external/compiler-rt/test/profile/Inputs/ |
| instrprof-dynamic-header.h | 0 template <class T> void bar() {
|
| /external/skia/experimental/webtry/templates/ |
| index.html | 5 {{template "headercommon.html" .}}
9 {{template "titlebar.html" .}}
10 {{template "content.html" .}}
16 {{template "footercommon.html" .}}
|
| /ndk/tests/build/issue-gcc59052-partial-specialization-of-template/jni/ |
| issue-gcc59052-partial-specialization-of-template.cc | 3 template <class T>
5 template <class U, T t>
9 template <class T>
10 template <T t>
|
| /external/clang/test/CXX/temp/temp.spec/temp.expl.spec/ |
| p2.cpp | 17 // -- function template
19 template<typename T> void f0(T) { // expected-note{{here}}
23 template<> void f0(NonDefaultConstructible) { }
29 template<> void f0(int);
30 template<> void f0(long);
33 template<> void N0::f0(int) { } // okay
36 template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
39 template<> void N0::f0(double); // expected-warning{{C++11 extension}}
40 template<> void N0::f0(double) { }
43 template<typename T> void f(T)
[all...] |
| p14.cpp | 3 template<class T> void f(T) { /* ... */ }
4 template<class T> inline void g(T) { /* ... */ }
7 template<> void g<>(int) { /* ... */ }
9 template<class T>
16 template<class T>
20 template<class T>
25 template<> void X<int>::f() { }
28 template<> void X<int>::h() { }
31 template<> inline void f<>(int) { /* ... */ }
34 template<> inline void X<int>::g() {
[all...] |
| /external/clang/test/CXX/temp/temp.decls/temp.class.spec/ |
| p9-0x.cpp | 4 // to the implicit argument list of the primary template.
6 template<typename T, typename ...Types>
9 template<typename T, typename ...Types>
10 struct X1<T, Types...> // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
|
| /external/clang/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/ |
| p1.cpp | 3 template<typename T, int N>
6 template<typename T>
18 template<class X> void A<X*, 2>::f(X*) { }
20 template<class X> X A<X*, 2>::value;
22 template<class X> A<X*, 2>::A(X) { value = 0; }
24 template<class X> A<X*, 2>::~A() { }
26 template<class X> A<X*, 2>::operator X*() { return 0; }
|
| /external/clang/test/CXX/temp/temp.type/ |
| p1-0x.cpp | 4 template<template<class> class TT> struct X { };
5 template<class> struct Y { };
6 template<class T> using Z = Y<T>;
15 template<class T> struct X { };
16 template<class> struct Y { };
17 template<class T> using Z = Y<T>;
|
| /external/clang/test/PCH/ |
| cxx-friends.h | 10 template<typename> class setter;
12 template<typename> class promise {
15 template<typename> friend class future_base::setter;
30 template <class T> struct valarray;
32 template <class T> struct valarray {
34 template <class U> friend struct valarray;
35 template <class U> friend U *begin(valarray<U> &v);
|
| cxx-ms-function-specialization-class-scope.h | 4 template <class T>
7 template <class U>
10 template <>
14 template <class U>
20 template <>
|
| /external/clang/test/Sema/ |
| template-specialization.cpp | 3 // template member functions.
6 template <typename T>
7 static void bar(int) { } // expected-note {{candidate template ignored: couldn't infer template argument 'T'}}
11 template <int i>
14 A::template bar(array[0]); // expected-error {{no matching function for call to 'bar'}}
19 B::foo<4>(); // expected-note {{in instantiation of function template specialization 'B::foo<4>'}}
|
| /external/clang/test/SemaCXX/ |
| PR9902.cpp | 4 template <class _Tp, class _Up, bool = false>
9 template <template <class, class...> class _Alloc, class _Tp, class ..._Args,
16 template <class Alloc>
19 template <class T> using rebind_alloc = typename __allocator_traits_rebind<Alloc, T>::type;
20 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
23 template <class T>
|
| cxx1y-variable-templates_top_level.cpp | 11 template<typename T>
12 T pi = T(3.1415926535897932385); // expected-note {{template is declared here}}
14 template<typename T>
15 CONST T cpi = T(3.1415926535897932385); // expected-note {{template is declared here}}
17 template<typename T> extern CONST T vc;
32 // template arguments are not deduced for uses of variable templates.
33 int ipi = pi; // expected-error {{cannot refer to variable template 'pi' without a template argument list}}
34 int icpi = cpi; // expected-error {{cannot refer to variable template 'cpi' without a template argument list}
[all...] |
| /external/clang/include/clang/Sema/ |
| ParsedTemplate.h | 1 //===--- ParsedTemplate.h - Template Parsing Data Types -------------------===//
22 /// \brief Represents the parsed form of a C++ template argument.
25 /// \brief Describes the kind of template argument that was parsed.
27 /// \brief A template type parameter, stored as a type.
29 /// \brief A non-type template parameter, stored as an expression.
31 /// \brief A template template argument, stored as a template name.
32 Template
35 /// \brief Build an empty template argument.
[all...] |
| /external/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/ |
| p17.cpp | 3 template<int i> class A { };
4 template<short s> void f(A<s>); // expected-note{{candidate template ignored: substitution failure}}
11 template<const short cs> class B { };
12 template<short s> void g(B<s>);
15 g(b); // OK: cv-qualifiers are ignored on template parameter types
18 template<short s> void h(int (&)[s]); // expected-note{{candidate function template not viable: requires 1 argument, but 2 were provided}}
25 template<short s> void h(int (&)[s], A<s>); // expected-note{{candidate template ignored: substitution failure}
[all...] |
| /external/clang/test/CXX/temp/temp.param/ |
| p2.cpp | 5 // template-parameter. typename followed by an unqualified-id names a
6 // template type parameter.
7 template<class T> struct X;
8 template<typename T> struct X;
12 template<typename T, typename T::type Value> struct Y0;
13 template<typename T, typename X<T>::type Value> struct Y1;
15 // A storage class shall not be specified in a template-parameter declaration.
16 template<static int Value> struct Z; // FIXME: expect an error
18 // Make sure that we properly disambiguate non-type template parameters that
21 template<class X1 *xptr> struct Y2 { }
[all...] |
| /external/clang/test/CXX/temp/temp.spec/temp.explicit/ |
| p8.cpp | 3 template<typename T>
12 template class X0<int(int)>; // ok; nothing gets instantiated.
14 template<typename T>
19 template<typename T>
24 template<typename T>
27 template class X0<int>; // ok
30 template<typename T>
36 template struct X1<int>; // expected-note {{here}}
38 extern template struct X1<char>; // ok
40 template struct X1<char>; // expected-note {{here}
[all...] |
| /external/clang/test/CXX/temp/temp.decls/temp.mem/ |
| p5.cpp | 3 template <class T> operator T*();
6 template <class T> A::operator T*() { return 0; }
7 template <> A::operator char*(){ return 0; } // specialization
8 template A::operator void*(); // explicit instantiation
18 template <class T> struct A { };
19 template <class T> struct B { };
22 template <class T> operator T();
35 template <typename T> operator T();
37 template <typename T>
42 template <typename T
[all...] |
| /external/clang/test/CXX/temp/temp.names/ |
| p2.cpp | 4 // Ensure that when enforcing access control an unqualified template name with
5 // explicit template arguments, we don't lose the context of the name lookup
6 // because of the required early lookup to determine if it names a template.
8 template <typename R, typename P> void h(R (*func)(P)) {}
10 template <typename T> static void g(T*) {};
|
