1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 3 template<typename ...Types> struct tuple; 4 template<unsigned> struct unsigned_c; 5 6 template<typename T, typename U> 7 struct is_same { 8 static const bool value = false; 9 }; 10 11 template<typename T> 12 struct is_same<T, T> { 13 static const bool value = true; 14 }; 15 16 namespace PackExpansionNotAtEnd { 17 template<typename T, typename U> 18 struct tuple_same_with_int { 19 static const bool value = false; 20 }; 21 22 template<typename ...Types> 23 struct tuple_same_with_int<tuple<Types...>, tuple<Types..., int>> { 24 static const bool value = true; 25 }; 26 27 int tuple_same_with_int_1[tuple_same_with_int<tuple<int, float, double>, 28 tuple<int, float, double, int> 29 >::value? 1 : -1]; 30 31 template<typename ... Types> struct UselessPartialSpec; 32 33 template<typename ... Types, // expected-note{{non-deducible template parameter 'Types'}} 34 typename Tail> // expected-note{{non-deducible template parameter 'Tail'}} 35 struct UselessPartialSpec<Types..., Tail>; // expected-error{{class template partial specialization contains template parameters that cannot be deduced; this partial specialization will never be used}} 36 } 37 38 // When a pack expansion occurs within a template argument list, the entire 39 // list is a non-deduced context. For the corresponding case in a function 40 // parameter list, only that parameter is non-deduced. 41 // 42 // FIXME: It's not clear that this difference is intended, but the wording is 43 // explicit. 44 namespace PackExpansionNotAtEndFunctionVersusTemplate { 45 template<typename ...T> struct X {}; 46 template<typename ...T, typename U> void f1(void(T..., U)); 47 // expected-note@+1 {{couldn't infer template argument 'U'}} 48 template<typename ...T, typename U> void f2(X<T..., U>); // FIXME: ill-formed, U is not deducible 49 50 void g(int, int, int); 51 X<int, int, int> h; test()52 void test() { 53 // This is deducible: the T... parameter is a non-deduced context, but 54 // that's OK because we don't need to deduce it. 55 f1<int, int>(g); 56 // This is not deducible: the T... parameter renders the entire 57 // template-argument-list a non-deduced context, so U is not deducible. 58 f2<int, int>(h); // expected-error {{no matching function}} 59 } 60 61 template<typename T> struct Y; 62 template<typename ...T, // expected-note {{non-deducible template parameter 'T'}} 63 typename U> 64 struct Y<void(T..., U)> {}; // expected-error {{cannot be deduced}} 65 template<typename ...T, // expected-note {{non-deducible template parameter 'T'}} 66 typename U> // expected-note {{non-deducible template parameter 'U'}} 67 struct Y<X<T..., U>>; // expected-error {{cannot be deduced}} 68 // FIXME: T is not deducible here, due to [temp.deduct.call]p1: 69 // "When a function parameter pack appears in a non-deduced context, 70 // the type of that pack is never deduced." 71 template<typename ...T, 72 typename U> 73 struct Y<void(T..., U, T...)> {}; 74 } 75 76 namespace DeduceNonTypeTemplateArgsInArray { 77 template<typename ...ArrayTypes> 78 struct split_arrays; 79 80 template<typename ...ElementTypes, unsigned ...Bounds> 81 struct split_arrays<ElementTypes[Bounds]...> { 82 typedef tuple<ElementTypes...> element_types; 83 84 // FIXME: Would like to have unsigned_tuple<Bounds...> here. 85 typedef tuple<unsigned_c<Bounds>...> bounds_types; 86 }; 87 88 int check1[is_same<split_arrays<int[1], float[2], double[3]>::element_types, 89 tuple<int, float, double>>::value? 1 : -1]; 90 int check2[is_same<split_arrays<int[1], float[2], double[3]>::bounds_types, 91 tuple<unsigned_c<1>, unsigned_c<2>, unsigned_c<3>> 92 >::value? 1 : -1]; 93 } 94 95 namespace DeduceWithDefaultArgs { 96 template<template<typename...> class Container> void f(Container<int>); // expected-note {{deduced type 'X<[...], (default) int>' of 1st parameter does not match adjusted type 'X<[...], double>' of argument [with Container = X]}} 97 template<typename, typename = int> struct X {}; g()98 void g() { 99 // OK, use default argument for the second template parameter. 100 f(X<int>{}); 101 f(X<int, int>{}); 102 103 // Not OK. 104 f(X<int, double>{}); // expected-error {{no matching function for call to 'f'}} 105 } 106 } 107