+ template <int* p> struct X0 { }; // expected-note 5{{here}}

+ struct S { union { int NonStaticMember; }; };

+ X0<&S::NonStaticMember> x0_non_static; // expected-error {{non-static data member}}

+

+template<typename ...T> void f(U<T> ...xs);

+void g() { f<void,void,void>(1, 2, 3); }

+

+// RUN: %clang_cc1 -std=c++1y -fsyntax-only -verify %s

+

+// -- The argument list of the specialization shall not be identical

+// to the implicit argument list of the primary template.

+

+template<typename T, int N, template<typename> class X> int v1;

+template<typename T, int N, template<typename> class X> int v1<T, N, X>;

+// expected-error@-1{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}

+

+template<typename...T> int v2;

+template<typename...T> int v2<T...>;

+// expected-error@-1{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}

+

+template<int...N> int v3;

+template<int...N> int v3<N...>;

+// expected-error@-1{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}

+

+template<template<typename> class...X> int v4;

+template<template<typename> class...X> int v4<X...>;

+// expected-error@-1{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}

+

+template<typename Outer> struct X {

+ template<typename Inner> static int y;

+ template<typename Inner> static int y<Outer>; // expected-warning {{can not be deduced}} expected-note {{'Inner'}}

+ template<typename Inner> static int y<Inner>; // expected-error {{does not specialize}}

+};

+template<typename Outer> template<typename Inner> int X<Outer>::y<Outer>; // expected-warning {{can not be deduced}} expected-note {{'Inner'}}

+template<typename Outer> template<typename Inner> int X<Outer>::y<Inner>; // expected-error {{does not specialize}}

+

+// FIXME: Merging this with the above class causes an assertion failure when

+// instantiating one of the bogus partial specializations.

+template<typename Outer> struct Y {

+ template<typename Inner> static int y;

+};

+template<> template<typename Inner> int Y<int>::y<Inner>; // expected-error {{does not specialize}}

+template<typename T> enum A<T>::E : T { e1, e2 }; // expected-note 2 {{declared here}}

+A<int>::E a1 = A<int>::e1; // expected-error {{no member named 'e1' in 'A<int>'; did you mean simply 'e1'?}}

+D<char>::E d4 = D<char>::E::e2; // expected-error {{no member named 'e2' in 'D<char>::E'; did you mean simply 'e2'?}}

+template<typename T> T x; // expected-warning{{variable templates are a C++1y extension}}

+

+namespace PR17075 {

+ template <typename T> struct V {};

+ struct S { template<typename T> S &operator>>(T &t) = delete; };

+ template<typename T> S &operator>>(S &s, V<T> &v);

+ void f(S s, V<int> v) { s >> v; }

+}

+

+template<typename T>

+struct X3 {

+ operator int();

+

+ friend void h(int x);

+};

+

+int array2[sizeof(X3<int>)];

+int array3[sizeof(X3<float>)];

+

+void i() {

+ X3<int> xi;

+ h(xi);

+ X3<float> xf;

+ h(xf);

+}

+ template <class T> friend class A<T>::Member; // expected-warning {{not supported}}

+ int n;

+ template <class T> friend struct A<T>::Inner; // expected-warning {{not supported}}

+ template<template <class> class U> friend void A<U>::foo();

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+template <typename>

+void quux();

+

+void fun() {

+ struct foo {

+ template <typename> struct bar {}; // expected-error{{templates cannot be declared inside of a local class}}

+ template <typename> void baz() {} // expected-error{{templates cannot be declared inside of a local class}}

+ template <typename> void qux(); // expected-error{{templates cannot be declared inside of a local class}}

+ };

+}

+ // expected-note{{in instantiation of function template specialization 'recurse_until_fail<char [7]>' requested here}} \

+ void member_function2() noexcept(Types()); // expected-error{{expression contains unexpanded parameter pack 'Types'}}

+

+namespace PR16303 {

+ template<int> struct A { A(int); };

+ template<int...N> struct B {

+ template<int...M> struct C : A<N>... {

+ C() : A<N>(M)... {} // expected-error{{pack expansion contains parameter packs 'N' and 'M' that have different lengths (2 vs. 3)}} expected-error{{pack expansion contains parameter packs 'N' and 'M' that have different lengths (4 vs. 3)}}

+ };

+ };

+ B<1,2>::C<4,5,6> c1; // expected-note{{in instantiation of}}

+ B<1,2,3,4>::C<4,5,6> c2; // expected-note{{in instantiation of}}

+}

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

+// expected-no-diagnostics

+

+namespace pr12262 {

+

+template<typename T, typename... Ts>

+void abc1(int (*xxx)[sizeof ... (Ts) + 1]);

+

+void qq1 () {

+ abc1<int>(0);

+ abc1<int,double>(0);

+}

+

+

+template <unsigned N> class array {};

+

+

+template<typename T, typename... Types>

+array<sizeof...(Types)> make_array1(Types&&... args);

+

+void qq2 () {

+ array<1> arr = make_array1<int>(1);

+ array<3> arr2 = make_array1<int>(1,array<5>(),0.1);

+}

+

+

+template<typename T, typename... Types>

+int make_array(array<sizeof...(Types)>&, Types... args);

+

+void qq3 () {

+ array<1> a1;

+ int aa1 = make_array<int>(a1,1);

+ array<2> a2;

+ int aa2 = make_array<int>(a2, 0L, "abc");

+}

+

+

+template<typename ... Ts>

+struct AAA {

+ template<typename T, typename... Types>

+ static array<sizeof...(Types)> make_array(Types ... args);

+};

+

+void qq4 () {

+ array<2> arr2 = AAA<int, int>::make_array<int>(1,2);

+}

+

+}

+

+

+namespace pr12439 {

+

+template<class... Members>

+struct X {

+ template<int Idx>

+ using get_t = decltype(sizeof...(Members));

+

+ template<int i>

+ get_t<i> get();

+};

+

+template<class... Members>

+template<int i>

+X<Members...>::get_t<i> X<Members...>::get()

+{

+ return 0;

+}

+

+}

+

+

+namespace pr13272 {

+

+template<bool B, class T = void>

+struct enable_if { };

+

+template<class T> struct enable_if<true, T> {

+ typedef T type;

+};

+

+class Exception {};

+

+template<class Ex, typename... Args>

+void cxx_throw(typename enable_if<(sizeof...(Args) > 0), const char *>::type fmt, Args&&... args) {

+ return;

+}

+

+void test() {

+ cxx_throw<Exception>("Youpi",1);

+}

+

+}

+

+

+namespace pr13817 {

+

+template <unsigned>

+struct zod;

+

+template <>

+struct zod<1> {};

+

+template <typename T, typename ... Ts>

+zod<sizeof...(Ts)> make_zod(Ts ...) {

+ return zod<sizeof...(Ts)>();

+}

+

+int main(int argc, char *argv[])

+{

+ make_zod<int>(1);

+ return 0;

+}

+

+}

+

+

+namespace pr14273 {

+

+template<typename T, int i>

+struct myType

+{ };

+

+template<typename T, typename... Args>

+struct Counter

+{

+ static const int count = 1 + Counter<Args...>::count;

+};

+

+template<typename T>

+struct Counter<T>

+{

+ static const int count = 1;

+};

+

+template<typename Arg, typename... Args>

+myType<Arg, sizeof...(Args)>* make_array_with_type(const Args&... args)

+{

+ return 0;

+}

+

+void func(void)

+{

+ make_array_with_type<char>(1,2,3);

+}

+

+}

+

+

+namespace pr15112

+{

+ template<bool, typename _Tp = void>

+ struct enable_if

+ { };

+ template<typename _Tp>

+ struct enable_if<true,_Tp>

+ { typedef _Tp type; };

+

+ typedef __typeof__(sizeof(int)) size_t;

+

+ template <size_t n, typename T, typename... Args>

+ struct is_array_of { static const bool value = true; };

+

+ struct cpu { using value_type = void; };

+

+ template <size_t Order, typename T>

+ struct coords_alias { typedef T type; };

+

+ template <size_t Order, typename MemoryTag>

+ using coords = typename coords_alias<Order, MemoryTag>::type;

+

+ template <typename MemTag, typename... Args>

+ typename enable_if<is_array_of<sizeof...(Args), size_t, Args...>::value,

+ coords<sizeof...(Args), MemTag>>::type

+ mkcoords(Args... args);

+

+ auto c1 = mkcoords<cpu>(0ul, 0ul, 0ul);

+}

+

+

+namespace pr12699 {

+

+template<bool B>

+struct bool_constant

+{

+ static const bool value = B;

+};

+

+template<typename... A>

+struct F

+{

+ template<typename... B>

+ using SameSize = bool_constant<sizeof...(A) == sizeof...(B)>;

+

+ template<typename... B, typename = SameSize<B...>>

+ F(B...) { }

+};

+

+void func()

+{

+ F<int> f1(3);

+}

+

+}

+ int &&r = I; // expected-warning 2{{binding reference member 'r' to a temporary value}} expected-note 2{{declared here}}

+S<5> s; // expected-note {{instantiation}}

+ int &&r = v; // expected-warning {{binding reference member 'r' to a temporary value}} expected-note {{declared here}}

+U<const int, 6> u; // expected-note {{instantiation}}

+// RUN: %clang_cc1 -verify %s -fcxx-exceptions -std=c++1y

+

+template<typename T, // expected-note {{declared here}}

+ typename T> struct X {}; // expected-error {{declaration of 'T' shadows template parameter}}

+

+template<typename T> struct Y { // expected-note 15{{declared here}}

+ template<typename T> struct A {}; // expected-error {{declaration of 'T' shadows template parameter}}

+

+ struct B {

+ template<typename> struct T {}; // FIXME: desired-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct C {

+ template<typename> void T(); // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct D {

+ struct T {}; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct E {

+ typedef int T; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct F {

+ using T = int; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct G {

+ int T; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct H {

+ static int T; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct I {

+ void T(); // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct J {

+ enum T { e }; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+ struct K {

+ enum E { T }; // expected-error {{declaration of 'T' shadows template parameter}}

+ };

+

+ void a() {

+ extern int T; // expected-error {{declaration of 'T' shadows template parameter}}

+ }

+ void b() {

+ int T; // expected-error {{declaration of 'T' shadows template parameter}}

+ }

+ void c() {

+ try {}

+ catch (int T) {} // expected-error {{declaration of 'T' shadows template parameter}}

+ }

+ void d() {

+ void T(); // expected-error {{declaration of 'T' shadows template parameter}}

+ }

+

+ friend struct T; // expected-error {{declaration of 'T' shadows template parameter}}

+};

+

+template<typename T> // expected-note {{declared here}}

+void f(int T) {} // expected-error {{declaration of 'T' shadows template parameter}}

+

+// FIXME: These are ill-formed: a template-parameter shall not have the same name as the template name.

+namespace A {

+ template<typename T> struct T {};

+}

+namespace B {

+ template<typename T> void T() {}

+}

+namespace C {

+ template<typename T> int T;

+}

+// RUN: %clang_cc1 --std=c++1y -fsyntax-only -verify %s

+// RUN: cp %s %t

+// RUN: not %clang_cc1 --std=c++1y -x c++ -fixit %t -DFIXING

+// RUN: %clang_cc1 --std=c++1y -x c++ %t -DFIXING

+

+template<typename T>

+T pi = T(3.1415926535897932385); // expected-note {{template is declared here}}

+

+template int pi<int>;

+

+#ifndef FIXING

+template float pi<>; // expected-error {{too few template arguments for template 'pi'}}

+template double pi_var0; // expected-error {{explicit instantiation of 'pi_var0' does not refer to a function template, variable template, member function, member class, or static data member}}

+#endif

+

+// Should recover as if definition

+template double pi_var = 5; // expected-error {{variable cannot be defined in an explicit instantiation; if this declaration is meant to be a variable definition, remove the 'template' keyword}}

+#ifndef FIXING

+template<typename T>

+T pi0 = T(3.1415926535897932385); // expected-note {{previous definition is here}}

+

+template int pi0 = 10; // expected-error {{variable cannot be defined in an explicit instantiation; if this declaration is meant to be a variable definition, remove the 'template' keyword}} \

+ expected-error{{redefinition of 'pi0' as different kind of symbol}}

+#endif

+

+template<typename T>

+T pi1 = T(3.1415926535897932385);

+

+// Should recover as if specialization

+template float pi1<float> = 1.0; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}

+#ifndef FIXING

+namespace expected_global {

+ template<> double pi1<double> = 1.5; // expected-error {{no variable template matches specialization}}

+ template int pi1<int> = 10; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \

+ expected-error {{no variable template matches specialization}}

+}

+#endif

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+// RUN: cp %s %t

+// RUN: not %clang_cc1 -x c++ -fixit %t -DFIXING

+// RUN: %clang_cc1 -x c++ %t -DFIXING

+

+template<typename T> void f(T) { }

+template<typename T> void g(T) { }

+template<typename T> struct x { };

+template<typename T> struct y { }; // expected-note {{declared here}}

+

+namespace good {

+ template void f<int>(int);

+ template void g(int);

+ template struct x<int>;

+}

+

+namespace unsupported {

+#ifndef FIXING

+ template struct y; // expected-error {{elaborated type refers to a template}}

+#endif

+}

+

+template<typename T> void f0(T) { }

+template<typename T> void g0(T) { }

+template<typename T> struct x0 { }; // expected-note {{explicitly specialized declaration is here}}

+template<typename T> struct y0 { };

+

+// Should recover as if definition

+namespace noargs_body {

+#ifndef FIXING

+ template void g0(int) { } // expected-error {{function cannot be defined in an explicit instantiation; if this declaration is meant to be a function definition, remove the 'template' keyword}}

+#endif

+ template struct y0 { }; // expected-error {{class cannot be defined in an explicit instantiation; if this declaration is meant to be a class definition, remove the 'template' keyword}}

+}

+

+// Explicit specializations expected in global scope

+namespace exp_spec {

+#ifndef FIXING

+ template<> void f0<int>(int) { } // expected-error {{no function template matches function template specialization 'f0'}}

+ template<> struct x0<int> { }; // expected-error {{class template specialization of 'x0' must originally be declared in the global scope}}

+#endif

+}

+

+template<typename T> void f1(T) { }

+template<typename T> struct x1 { }; // expected-note {{explicitly specialized declaration is here}}

+

+// Should recover as if specializations,

+// thus also complain about not being in global scope.

+namespace args_bad {

+#ifndef FIXING

+ template void f1<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \

+ expected-error {{no function template matches function template specialization 'f1'}}

+ template struct x1<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \

+ expected-error {{class template specialization of 'x1' must originally be declared in the global scope}}

+#endif

+}

+

+template<typename T> void f2(T) { }

+template<typename T> struct x2 { };

+

+// Should recover as if specializations

+template void f2<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}

+template struct x2<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}

+ template<> const int X<1>::Y::Z; // expected-error{{extraneous 'template<>' in declaration of variable 'Z'}}

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns -emit-llvm -std=c++11 -o - %s | FileCheck %s

+ // DR1484 specifies that enumerations cannot be separately instantiated,

+ // they will be instantiated with the rest of the template declaration.

+ e = T::error // expected-error {{has no members}}

+ int test1 = f<int>(); // expected-note {{here}}

+ return E::e;