head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.7 netbsd-11-0-RC3:1.1.1.7 netbsd-11-0-RC2:1.1.1.7 netbsd-11-0-RC1:1.1.1.7 perseant-exfatfs-base-20250801:1.1.1.7 netbsd-11:1.1.1.7.0.10 netbsd-11-base:1.1.1.7 netbsd-10-1-RELEASE:1.1.1.7 perseant-exfatfs-base-20240630:1.1.1.7 perseant-exfatfs:1.1.1.7.0.8 perseant-exfatfs-base:1.1.1.7 netbsd-8-3-RELEASE:1.1.1.5 netbsd-9-4-RELEASE:1.1.1.6 netbsd-10-0-RELEASE:1.1.1.7 netbsd-10-0-RC6:1.1.1.7 netbsd-10-0-RC5:1.1.1.7 netbsd-10-0-RC4:1.1.1.7 netbsd-10-0-RC3:1.1.1.7 netbsd-10-0-RC2:1.1.1.7 netbsd-10-0-RC1:1.1.1.7 netbsd-10:1.1.1.7.0.6 netbsd-10-base:1.1.1.7 netbsd-9-3-RELEASE:1.1.1.6 cjep_sun2x:1.1.1.7.0.4 cjep_sun2x-base:1.1.1.7 cjep_staticlib_x-base1:1.1.1.7 netbsd-9-2-RELEASE:1.1.1.6 cjep_staticlib_x:1.1.1.7.0.2 cjep_staticlib_x-base:1.1.1.7 netbsd-9-1-RELEASE:1.1.1.6 phil-wifi-20200421:1.1.1.7 phil-wifi-20200411:1.1.1.7 phil-wifi-20200406:1.1.1.7 netbsd-8-2-RELEASE:1.1.1.5 netbsd-9-0-RELEASE:1.1.1.6 netbsd-9-0-RC2:1.1.1.6 netbsd-9-0-RC1:1.1.1.6 netbsd-9:1.1.1.6.0.6 netbsd-9-base:1.1.1.6 phil-wifi-20190609:1.1.1.6 netbsd-8-1-RELEASE:1.1.1.5 netbsd-8-1-RC1:1.1.1.5 pgoyette-compat-merge-20190127:1.1.1.6 pgoyette-compat-20190127:1.1.1.6 pgoyette-compat-20190118:1.1.1.6 pgoyette-compat-1226:1.1.1.6 pgoyette-compat-1126:1.1.1.6 pgoyette-compat-1020:1.1.1.6 pgoyette-compat-0930:1.1.1.6 pgoyette-compat-0906:1.1.1.6 netbsd-7-2-RELEASE:1.1.1.1.6.1 pgoyette-compat-0728:1.1.1.6 clang-337282:1.1.1.6 netbsd-8-0-RELEASE:1.1.1.5 phil-wifi:1.1.1.6.0.4 phil-wifi-base:1.1.1.6 pgoyette-compat-0625:1.1.1.6 netbsd-8-0-RC2:1.1.1.5 pgoyette-compat-0521:1.1.1.6 pgoyette-compat-0502:1.1.1.6 pgoyette-compat-0422:1.1.1.6 netbsd-8-0-RC1:1.1.1.5 pgoyette-compat-0415:1.1.1.6 pgoyette-compat-0407:1.1.1.6 pgoyette-compat-0330:1.1.1.6 pgoyette-compat-0322:1.1.1.6 pgoyette-compat-0315:1.1.1.6 netbsd-7-1-2-RELEASE:1.1.1.1.6.1 pgoyette-compat:1.1.1.6.0.2 pgoyette-compat-base:1.1.1.6 netbsd-7-1-1-RELEASE:1.1.1.1.6.1 clang-319952:1.1.1.6 matt-nb8-mediatek:1.1.1.5.0.8 matt-nb8-mediatek-base:1.1.1.5 clang-309604:1.1.1.6 perseant-stdc-iso10646:1.1.1.5.0.6 perseant-stdc-iso10646-base:1.1.1.5 netbsd-8:1.1.1.5.0.4 netbsd-8-base:1.1.1.5 prg-localcount2-base3:1.1.1.5 prg-localcount2-base2:1.1.1.5 prg-localcount2-base1:1.1.1.5 prg-localcount2:1.1.1.5.0.2 prg-localcount2-base:1.1.1.5 pgoyette-localcount-20170426:1.1.1.5 bouyer-socketcan-base1:1.1.1.5 pgoyette-localcount-20170320:1.1.1.5 netbsd-7-1:1.1.1.1.6.1.0.6 netbsd-7-1-RELEASE:1.1.1.1.6.1 netbsd-7-1-RC2:1.1.1.1.6.1 clang-294123:1.1.1.5 netbsd-7-nhusb-base-20170116:1.1.1.1.6.1 bouyer-socketcan:1.1.1.4.0.2 bouyer-socketcan-base:1.1.1.4 clang-291444:1.1.1.4 pgoyette-localcount-20170107:1.1.1.3 netbsd-7-1-RC1:1.1.1.1.6.1 pgoyette-localcount-20161104:1.1.1.3 netbsd-7-0-2-RELEASE:1.1.1.1.6.1 localcount-20160914:1.1.1.3 netbsd-7-nhusb:1.1.1.1.6.1.0.4 netbsd-7-nhusb-base:1.1.1.1.6.1 clang-280599:1.1.1.3 pgoyette-localcount-20160806:1.1.1.3 pgoyette-localcount-20160726:1.1.1.3 pgoyette-localcount:1.1.1.3.0.2 pgoyette-localcount-base:1.1.1.3 netbsd-7-0-1-RELEASE:1.1.1.1.6.1 clang-261930:1.1.1.3 netbsd-7-0:1.1.1.1.6.1.0.2 netbsd-7-0-RELEASE:1.1.1.1.6.1 netbsd-7-0-RC3:1.1.1.1.6.1 netbsd-7-0-RC2:1.1.1.1.6.1 netbsd-7-0-RC1:1.1.1.1.6.1 clang-237755:1.1.1.2 clang-232565:1.1.1.2 clang-227398:1.1.1.2 tls-maxphys-base:1.1.1.1 tls-maxphys:1.1.1.1.0.8 netbsd-7:1.1.1.1.0.6 netbsd-7-base:1.1.1.1 clang-215315:1.1.1.1 clang-209886:1.1.1.1 yamt-pagecache:1.1.1.1.0.4 yamt-pagecache-base9:1.1.1.1 tls-earlyentropy:1.1.1.1.0.2 tls-earlyentropy-base:1.1.1.1 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1 riastradh-drm2-base3:1.1.1.1 clang-202566:1.1.1.1 clang-201163:1.1.1.1 clang-199312:1.1.1.1 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches 1.1.1.1.4.1 1.1.1.1.6.1 1.1.1.1.8.1; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2015.01.29.19.57.37; author joerg; state Exp; branches; next 1.1.1.3; commitid mlISSizlPKvepX7y; 1.1.1.3 date 2016.02.27.22.08.57; author joerg; state Exp; branches 1.1.1.3.2.1; next 1.1.1.4; commitid tIimz3oDlh1NpBWy; 1.1.1.4 date 2017.01.11.10.37.02; author joerg; state Exp; branches 1.1.1.4.2.1; next 1.1.1.5; commitid CNnUNfII1jgNmxBz; 1.1.1.5 date 2017.02.09.17.38.55; author joerg; state Exp; branches; next 1.1.1.6; commitid UxB8JMFWM7xyMiFz; 1.1.1.6 date 2017.08.01.19.34.16; author joerg; state Exp; branches 1.1.1.6.4.1; next 1.1.1.7; commitid pMuDy65V0VicSx1A; 1.1.1.7 date 2019.11.13.22.22.59; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.4.1 date 2013.11.28.14.14.54; author yamt; state dead; branches; next 1.1.1.1.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.1.4.2 date 2014.05.22.16.19.45; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.1.6.1 date 2015.06.04.20.04.45; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.1.8.1 date 2013.11.28.14.14.54; author tls; state dead; branches; next 1.1.1.1.8.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.1.8.2 date 2014.08.19.23.49.24; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.3.2.1 date 2017.03.20.06.53.35; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.4.2.1 date 2017.04.21.16.51.43; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.6.4.1 date 2020.04.13.07.50.27; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @// RUN: %clang_cc1 -fsyntax-only -verify %s // Template argument deduction with template template parameters. template class A> struct X0 { static const unsigned value = 0; }; template class A> struct X0 { static const unsigned value = 1; }; template struct X0i; template struct X0l; int array_x0a[X0::value == 0? 1 : -1]; int array_x0b[X0::value == 1? 1 : -1]; template struct is_same { static const bool value = false; }; template struct is_same { static const bool value = true; }; template struct allocator { }; template > struct vector {}; // Fun with meta-lambdas! struct _1 {}; struct _2 {}; // Replaces all occurrences of _1 with Arg1 and _2 with Arg2 in T. template struct Replace { typedef T type; }; // Replacement of the whole type. template struct Replace<_1, Arg1, Arg2> { typedef Arg1 type; }; template struct Replace<_2, Arg1, Arg2> { typedef Arg2 type; }; // Replacement through cv-qualifiers template struct Replace { typedef typename Replace::type const type; }; // Replacement of templates template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type> type; }; template class TT, typename T1, typename T2, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, typename Replace::type> type; }; // Just for kicks... template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, Arg2> type; }; int array0[is_same::type, int>::value? 1 : -1]; int array1[is_same::type, const int>::value? 1 : -1]; int array2[is_same, int, float>::type, vector >::value? 1 : -1]; int array3[is_same, int, float>::type, vector >::value? 1 : -1]; int array4[is_same, double, float>::type, vector >::value? 1 : -1]; // PR5911 template void f(const T (&a)[N]); int iarr[] = { 1 }; void test_PR5911() { f(iarr); } // Must not examine base classes of incomplete type during template argument // deduction. namespace PR6257 { template struct X { template X(const X& u); }; struct A; void f(A& a); void f(const X& a); void test(A& a) { (void)f(a); } } // PR7463 namespace PR7463 { const int f (); template void g (T_&); // expected-note{{T_ = int}} void h (void) { g(f()); } // expected-error{{no matching function for call}} } namespace test0 { template void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'char'}} char *char_maker(); void test() { make(char_maker); // expected-error {{no matching function for call to 'make'}} } } namespace test1 { template void foo(const T a[3][3]); void test() { int a[3][3]; foo(a); } } // PR7708 namespace test2 { template struct Const { typedef void const type; }; template void f(T, typename Const::type*); template void f(T, void const *); void test() { void *p = 0; f(0, p); } } // rdar://problem/8537391 namespace test3 { struct Foo { template static inline void foo(); }; class Bar { template static inline void wobble(T ch); public: static void madness() { Foo::foo >(); } }; } // Verify that we can deduce enum-typed arguments correctly. namespace test14 { enum E { E0, E1 }; template struct A {}; template void foo(const A &a) {} void test() { A a; foo(a); } } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.1.6.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d1 1 a1 1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 d110 1 a110 1 template void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'char'}} a164 40 namespace PR21536 { template struct X; template struct S { static_assert(sizeof...(B) == 1, ""); void f() { using T = A; using T = int; using U = X; using U = X; } }; template void f(S); void g() { f(S()); } } namespace PR19372 { template class C, typename ...Us> struct BindBack { template using apply = C; }; template struct Y; template using Z = Y; using T = BindBack::apply<>; using T = Z; using U = BindBack::apply; using U = Z; namespace BetterReduction { template struct S; template using X = S; // expected-note {{parameter}} template using Y = X; template using Z = X; // expected-error {{must be a type}} using T = Y; using T = S; } } @ 1.1.1.2 log @Import Clang 3.6RC1 r227398. @ text @d1 1 a1 1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 d110 1 a110 1 template void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'char'}} a164 40 namespace PR21536 { template struct X; template struct S { static_assert(sizeof...(B) == 1, ""); void f() { using T = A; using T = int; using U = X; using U = X; } }; template void f(S); void g() { f(S()); } } namespace PR19372 { template class C, typename ...Us> struct BindBack { template using apply = C; }; template struct Y; template using Z = Y; using T = BindBack::apply<>; using T = Z; using U = BindBack::apply; using U = Z; namespace BetterReduction { template struct S; template using X = S; // expected-note {{parameter}} template using Y = X; template using Z = X; // expected-error {{must be a type}} using T = Y; using T = S; } } @ 1.1.1.3 log @Import Clang 3.8.0rc3 r261930. @ text @d110 1 a110 1 template void make(const T *(*fn)()); // expected-note {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}} a204 16 namespace PR18645 { template F Quux(F &&f); auto Baz = Quux(Quux); } namespace NonDeducedNestedNameSpecifier { template struct A { template struct B { B(int) {} }; }; template int f(A, typename A::template B); int k = f(A(), 0); } @ 1.1.1.3.2.1 log @Sync with HEAD @ text @a1 1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1z a220 262 namespace PR27601_RecursivelyInheritedBaseSpecializationsDeductionAmbiguity { namespace ns1 { template struct B { }; template struct B : B<> { }; template struct D : B { }; template void f(B &) { } int main() { D d; f(d); } } //end ns1 namespace ns2 { template struct tup_impl; template struct tup_impl {}; // empty tail template struct tup_impl : tup_impl { using value_type = Head; Head head; }; template struct tup : tup_impl<0, Es...> {}; template Head &get_helper(tup_impl &t) { return t.head; } template Head const &get_helper(tup_impl const &t) { return t.head; } int main() { tup t; get_helper(t); return 0; } } // end ns2 } namespace multiple_deduction_different_type { template struct X {}; template class X, typename T, typename U, int N> void f(X, X) {} // expected-note 2{{values of conflicting types}} template class X, typename T, typename U, const int *N> void g(X, X) {} // expected-note 0-2{{values of conflicting types}} int n; void h() { f(X(), X()); // expected-error {{no matching function}} f(X(), X()); // expected-error {{no matching function}} #if __cplusplus > 201402L g(X(), X()); // expected-error {{no matching function}} g(X(), X()); // expected-error {{no matching function}} #endif } template class X, typename T, typename U, T N> void x(X, int(*)[N], X) {} // expected-note 1+{{candidate}} template class X, typename T, typename U, T N> void x(int(*)[N], X, X) {} // expected-note 1+{{candidate}} int arr[3]; void y() { x(X(), &arr, X()); x(&arr, X(), X()); x(X(), &arr, X()); // expected-error {{no matching function}} x(&arr, X(), X()); // expected-error {{no matching function}} x(X(), &arr, X()); x(&arr, X(), X()); } } namespace nullptr_deduction { using nullptr_t = decltype(nullptr); template struct X {}; template void f(X) { static_assert(!v, ""); } void g() { f(X()); f(X()); } template class X, typename T, typename U, int *P> void f1(X, X) {} // expected-note 2{{values of conflicting types}} void h() { f1(X(), X()); // expected-error {{no matching function}} f1(X(), X()); // expected-error {{no matching function}} } template class X, typename T, typename U, nullptr_t P> void f2(X, X) {} // expected-note 2{{values of conflicting types}} void i() { f2(X(), X()); // expected-error {{no matching function}} f2(X(), X()); // expected-error {{no matching function}} } } namespace member_pointer { struct A { void f(int); }; template struct B; template struct C; template struct C> { C() { A a; T t; (a.*F)(t); } }; C> c; } namespace deduction_substitution_failure { template struct Fail { typedef typename T::error error; }; // expected-error 2{{prior to '::'}} template struct A {}; template struct A::error> {}; // expected-note {{instantiation of}} A ai; // expected-note {{during template argument deduction for class template partial specialization 'A::error>' [with T = int]}} expected-note {{in instantiation of template class 'deduction_substitution_failure::A'}} template int B; // expected-warning 0-1 {{extension}} template int B::error> {}; // expected-note {{instantiation of}} int bi = B; // expected-note {{during template argument deduction for variable template partial specialization 'B::error>' [with T = char]}} } namespace deduction_after_explicit_pack { template int *f(T ...t, int &r, U *u) { return u; } template int *g(T ...t, int &r, U *u) { return u; } void h(float a, double b, int c) { f(a, b, c, &c); // ok g(a, b, c, &c); // ok } template int test(ExtraArgs..., unsigned vla_size, const char *input); int n = test(0, ""); template void i(T..., int, T..., ...); // expected-note 5{{deduced conflicting}} void j() { i(0); i(0, 1); // expected-error {{no match}} i(0, 1, 2); // expected-error {{no match}} i<>(0); i<>(0, 1); // expected-error {{no match}} i<>(0, 1, 2); // expected-error {{no match}} i(0, 1, 2, 3, 4); i(0, 1, 2, 3, 4, 5); // expected-error {{no match}} } // GCC alarmingly accepts this by deducing T={int} by matching the second // parameter against the first argument, then passing the first argument // through the first parameter. template struct X { X(int); operator int(); }; template void p(T..., X, ...); // expected-note {{deduced conflicting}} void q() { p(X(0), 0); } // expected-error {{no match}} struct A { template void f(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void f(); // expected-note 2{{requires 0}} template static void g(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void g(); // expected-note 2{{requires 0}} void h() { f(1.0, 2.0); // expected-error {{no match}} g(1.0, 2.0); // expected-error {{no match}} } }; void f(A a) { a.f(1.0, 2.0); // expected-error {{no match}} a.g(1.0, 2.0); // expected-error {{no match}} } } namespace overload_vs_pack { void f(int); void f(float); void g(double); template struct X {}; template void x(T...); template struct Y { typedef int type(typename T::error...); }; template<> struct Y { typedef int type; }; template typename Y::type g1(X, void (*...fns)(T)); // expected-note {{deduced conflicting types for parameter 'T' ( vs. <(no value), double>)}} template typename Y::type g2(void(*)(T...), void (*...fns)(T)); // expected-note {{deduced conflicting types for parameter 'T' ( vs. <(no value), double>)}} template int &h1(decltype(g1(X(), f, f, g)) *p); template float &h1(...); template int &h2(decltype(g2(x, f, f, g)) *p); template float &h2(...); int n1 = g1(X(), f, g); // expected-error {{no matching function}} int n2 = g2(x, f, g); // expected-error {{no matching function}} int &a1 = h1(0); // ok, skip deduction for 'f's, deduce matching value from 'g' int &a2 = h2(0); float &b1 = h1(0); // deduce mismatching value from 'g', so we do not trigger instantiation of Y float &b2 = h2(0); template int partial_deduction(void (*...f)(T)); // expected-note {{deduced incomplete pack <(no value), double> for template parameter 'T'}} int pd1 = partial_deduction(f, g); // expected-error {{no matching function}} template int partial_deduction_2(void (*...f)(T), ...); // expected-note {{deduced incomplete pack <(no value), double> for template parameter 'T'}} int pd2 = partial_deduction_2(f, g); // expected-error {{no matching function}} namespace cwg_example { void f(char, char); void f(int, int); void x(int, char); template void j(void(*)(U...), void (*...fns)(T, U)); void test() { j(x, f, x); } } } namespace b29946541 { template class A {}; template class C> void f(C); // expected-note {{failed template argument deduction}} void g(A a) { f(a); } // expected-error {{no match}} } namespace deduction_from_empty_list { template void f(int (&&)[N], int (&&)[N]) { // expected-note {{1 vs. 2}} static_assert(M == N, ""); } void test() { f<5>({}, {}); f<1>({}, {0}); f<1>({0}, {}); f<1>({0}, {0}); f<1>({0}, {0, 1}); // expected-error {{no matching}} } } namespace check_extended_pack { template struct X { typedef int type; }; template void f(typename X::type...); template void f(T, int, int); void g() { f(0, 0, 0); } template struct Y {}; template void g(Y); // expected-note {{deduced non-type template argument does not have the same type as the corresponding template parameter ('int *' vs 'int')}} int n; void h() { g<0>(Y<0, &n>()); } // expected-error {{no matching function}} } @ 1.1.1.4 log @Import Clang pre-4.0.0 r291444. @ text @a1 1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1z a220 245 namespace PR27601_RecursivelyInheritedBaseSpecializationsDeductionAmbiguity { namespace ns1 { template struct B { }; template struct B : B<> { }; template struct D : B { }; template void f(B &) { } int main() { D d; f(d); } } //end ns1 namespace ns2 { template struct tup_impl; template struct tup_impl {}; // empty tail template struct tup_impl : tup_impl { using value_type = Head; Head head; }; template struct tup : tup_impl<0, Es...> {}; template Head &get_helper(tup_impl &t) { return t.head; } template Head const &get_helper(tup_impl const &t) { return t.head; } int main() { tup t; get_helper(t); return 0; } } // end ns2 } namespace multiple_deduction_different_type { template struct X {}; template class X, typename T, typename U, int N> void f(X, X) {} // expected-note 2{{values of conflicting types}} template class X, typename T, typename U, const int *N> void g(X, X) {} // expected-note 0-2{{values of conflicting types}} int n; void h() { f(X(), X()); // expected-error {{no matching function}} f(X(), X()); // expected-error {{no matching function}} #if __cplusplus > 201402L g(X(), X()); // expected-error {{no matching function}} g(X(), X()); // expected-error {{no matching function}} #endif } template class X, typename T, typename U, T N> void x(X, int(*)[N], X) {} // expected-note 1+{{candidate}} template class X, typename T, typename U, T N> void x(int(*)[N], X, X) {} // expected-note 1+{{candidate}} int arr[3]; void y() { x(X(), &arr, X()); x(&arr, X(), X()); x(X(), &arr, X()); // expected-error {{no matching function}} x(&arr, X(), X()); // expected-error {{no matching function}} x(X(), &arr, X()); x(&arr, X(), X()); } } namespace nullptr_deduction { using nullptr_t = decltype(nullptr); template struct X {}; template void f(X) { static_assert(!v, ""); } void g() { f(X()); f(X()); } template class X, typename T, typename U, int *P> void f1(X, X) {} // expected-note 2{{values of conflicting types}} void h() { f1(X(), X()); // expected-error {{no matching function}} f1(X(), X()); // expected-error {{no matching function}} } template class X, typename T, typename U, nullptr_t P> void f2(X, X) {} // expected-note 2{{values of conflicting types}} void i() { f2(X(), X()); // expected-error {{no matching function}} f2(X(), X()); // expected-error {{no matching function}} } } namespace member_pointer { struct A { void f(int); }; template struct B; template struct C; template struct C> { C() { A a; T t; (a.*F)(t); } }; C> c; } namespace deduction_substitution_failure { template struct Fail { typedef typename T::error error; }; // expected-error 2{{prior to '::'}} template struct A {}; template struct A::error> {}; // expected-note {{instantiation of}} A ai; // expected-note {{during template argument deduction for class template partial specialization 'A::error>' [with T = int]}} expected-note {{in instantiation of template class 'deduction_substitution_failure::A'}} template int B; // expected-warning 0-1 {{extension}} template int B::error> {}; // expected-note {{instantiation of}} int bi = B; // expected-note {{during template argument deduction for variable template partial specialization 'B::error>' [with T = char]}} } namespace deduction_after_explicit_pack { template int *f(T ...t, int &r, U *u) { return u; } template int *g(T ...t, int &r, U *u) { return u; } void h(float a, double b, int c) { f(a, b, c, &c); // ok g(a, b, c, &c); // ok } template int test(ExtraArgs..., unsigned vla_size, const char *input); int n = test(0, ""); template void i(T..., int, T..., ...); // expected-note 5{{deduced conflicting}} void j() { i(0); i(0, 1); // expected-error {{no match}} i(0, 1, 2); // expected-error {{no match}} i<>(0); i<>(0, 1); // expected-error {{no match}} i<>(0, 1, 2); // expected-error {{no match}} i(0, 1, 2, 3, 4); i(0, 1, 2, 3, 4, 5); // expected-error {{no match}} } // GCC alarmingly accepts this by deducing T={int} by matching the second // parameter against the first argument, then passing the first argument // through the first parameter. template struct X { X(int); operator int(); }; template void p(T..., X, ...); // expected-note {{deduced conflicting}} void q() { p(X(0), 0); } // expected-error {{no match}} } namespace overload_vs_pack { void f(int); void f(float); void g(double); template struct X {}; template void x(T...); template struct Y { typedef int type(typename T::error...); }; template<> struct Y { typedef int type; }; template typename Y::type g1(X, void (*...fns)(T)); // expected-note {{deduced conflicting types for parameter 'T' ( vs. <(no value), double>)}} template typename Y::type g2(void(*)(T...), void (*...fns)(T)); // expected-note {{deduced conflicting types for parameter 'T' ( vs. <(no value), double>)}} template int &h1(decltype(g1(X(), f, f, g)) *p); template float &h1(...); template int &h2(decltype(g2(x, f, f, g)) *p); template float &h2(...); int n1 = g1(X(), f, g); // expected-error {{no matching function}} int n2 = g2(x, f, g); // expected-error {{no matching function}} int &a1 = h1(0); // ok, skip deduction for 'f's, deduce matching value from 'g' int &a2 = h2(0); float &b1 = h1(0); // deduce mismatching value from 'g', so we do not trigger instantiation of Y float &b2 = h2(0); template int partial_deduction(void (*...f)(T)); // expected-note {{deduced incomplete pack <(no value), double> for template parameter 'T'}} int pd1 = partial_deduction(f, g); // expected-error {{no matching function}} template int partial_deduction_2(void (*...f)(T), ...); // expected-note {{deduced incomplete pack <(no value), double> for template parameter 'T'}} int pd2 = partial_deduction_2(f, g); // expected-error {{no matching function}} namespace cwg_example { void f(char, char); void f(int, int); void x(int, char); template void j(void(*)(U...), void (*...fns)(T, U)); void test() { j(x, f, x); } } } namespace b29946541 { template class A {}; template class C> void f(C); // expected-note {{failed template argument deduction}} void g(A a) { f(a); } // expected-error {{no match}} } namespace deduction_from_empty_list { template void f(int (&&)[N], int (&&)[N]) { // expected-note {{1 vs. 2}} static_assert(M == N, ""); } void test() { f<5>({}, {}); f<1>({}, {0}); f<1>({0}, {}); f<1>({0}, {0}); f<1>({0}, {0, 1}); // expected-error {{no matching}} } } namespace check_extended_pack { template struct X { typedef int type; }; template void f(typename X::type...); template void f(T, int, int); void g() { f(0, 0, 0); } template struct Y {}; template void g(Y); // expected-note {{deduced non-type template argument does not have the same type as the corresponding template parameter ('int *' vs 'int')}} int n; void h() { g<0>(Y<0, &n>()); } // expected-error {{no matching function}} } @ 1.1.1.4.2.1 log @Sync with HEAD @ text @a385 17 struct A { template void f(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void f(); // expected-note 2{{requires 0}} template static void g(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void g(); // expected-note 2{{requires 0}} void h() { f(1.0, 2.0); // expected-error {{no match}} g(1.0, 2.0); // expected-error {{no match}} } }; void f(A a) { a.f(1.0, 2.0); // expected-error {{no match}} a.g(1.0, 2.0); // expected-error {{no match}} } @ 1.1.1.5 log @Import Clang 4.0RC1 r294123. @ text @a385 17 struct A { template void f(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void f(); // expected-note 2{{requires 0}} template static void g(T, void *, int = 0); // expected-note 2{{no known conversion from 'double' to 'void *' for 2nd argument}} void g(); // expected-note 2{{requires 0}} void h() { f(1.0, 2.0); // expected-error {{no match}} g(1.0, 2.0); // expected-error {{no match}} } }; void f(A a) { a.f(1.0, 2.0); // expected-error {{no match}} a.g(1.0, 2.0); // expected-error {{no match}} } @ 1.1.1.6 log @Import clang r309604 from branches/release_50 @ text @d308 1 a308 1 static_assert(!v, ""); // expected-warning 2{{implicit conversion of nullptr constant to 'bool'}} d311 2 a312 2 f(X()); // expected-note {{instantiation of}} f(X()); // expected-note {{instantiation of}} a483 58 namespace dependent_template_template_param_non_type_param_type { template struct A { template class W> A(W); }; int n[12]; template struct Q {}; Q<&n> qn; A<0> a(qn); } namespace dependent_list_deduction { template void a(const int (&)[V]) { static_assert(is_same::value, ""); static_assert(V == 3, ""); } template void b(const T (&)[V]) { static_assert(is_same::value, ""); static_assert(V == 3, ""); } template void c(const T (&)[V]) { static_assert(is_same::value, ""); static_assert(V == 3, ""); } void d() { a({1, 2, 3}); #if __cplusplus <= 201402L // expected-error@@-2 {{no match}} expected-note@@-15 {{couldn't infer template argument 'T'}} #endif b({1, 2, 3}); c({{}, {}, {}}); #if __cplusplus <= 201402L // expected-error@@-2 {{no match}} expected-note@@-12 {{couldn't infer template argument 'T'}} #endif } template struct X; template struct Y; template void f(const T (&...p)[V]) { static_assert(is_same, X>::value, ""); static_assert(is_same, Y<3, 2, 4>>::value, ""); } template void g(const T (&...p)[V]) { static_assert(is_same, X>::value, ""); static_assert(is_same, Y<2, 3>>::value, ""); } void h() { f({1, 2, 3}, {'a', 'b'}, "foo"); g({1, 2}, {{}, {}, {}}); #if __cplusplus <= 201402 // expected-error@@-2 {{no match}} // expected-note@@-9 {{deduced incomplete pack}} // We deduce V$1 = (size_t)3, which in C++1z also deduces T$1 = size_t. #endif } } @ 1.1.1.6.4.1 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.7 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.8.1 log @file deduction.cpp was added on branch tls-maxphys on 2014-08-19 23:49:24 +0000 @ text @d1 164 @ 1.1.1.1.8.2 log @Rebase to HEAD as of a few days ago. @ text @a0 164 // RUN: %clang_cc1 -fsyntax-only -verify %s // Template argument deduction with template template parameters. template class A> struct X0 { static const unsigned value = 0; }; template class A> struct X0 { static const unsigned value = 1; }; template struct X0i; template struct X0l; int array_x0a[X0::value == 0? 1 : -1]; int array_x0b[X0::value == 1? 1 : -1]; template struct is_same { static const bool value = false; }; template struct is_same { static const bool value = true; }; template struct allocator { }; template > struct vector {}; // Fun with meta-lambdas! struct _1 {}; struct _2 {}; // Replaces all occurrences of _1 with Arg1 and _2 with Arg2 in T. template struct Replace { typedef T type; }; // Replacement of the whole type. template struct Replace<_1, Arg1, Arg2> { typedef Arg1 type; }; template struct Replace<_2, Arg1, Arg2> { typedef Arg2 type; }; // Replacement through cv-qualifiers template struct Replace { typedef typename Replace::type const type; }; // Replacement of templates template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type> type; }; template class TT, typename T1, typename T2, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, typename Replace::type> type; }; // Just for kicks... template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, Arg2> type; }; int array0[is_same::type, int>::value? 1 : -1]; int array1[is_same::type, const int>::value? 1 : -1]; int array2[is_same, int, float>::type, vector >::value? 1 : -1]; int array3[is_same, int, float>::type, vector >::value? 1 : -1]; int array4[is_same, double, float>::type, vector >::value? 1 : -1]; // PR5911 template void f(const T (&a)[N]); int iarr[] = { 1 }; void test_PR5911() { f(iarr); } // Must not examine base classes of incomplete type during template argument // deduction. namespace PR6257 { template struct X { template X(const X& u); }; struct A; void f(A& a); void f(const X& a); void test(A& a) { (void)f(a); } } // PR7463 namespace PR7463 { const int f (); template void g (T_&); // expected-note{{T_ = int}} void h (void) { g(f()); } // expected-error{{no matching function for call}} } namespace test0 { template void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'char'}} char *char_maker(); void test() { make(char_maker); // expected-error {{no matching function for call to 'make'}} } } namespace test1 { template void foo(const T a[3][3]); void test() { int a[3][3]; foo(a); } } // PR7708 namespace test2 { template struct Const { typedef void const type; }; template void f(T, typename Const::type*); template void f(T, void const *); void test() { void *p = 0; f(0, p); } } // rdar://problem/8537391 namespace test3 { struct Foo { template static inline void foo(); }; class Bar { template static inline void wobble(T ch); public: static void madness() { Foo::foo >(); } }; } // Verify that we can deduce enum-typed arguments correctly. namespace test14 { enum E { E0, E1 }; template struct A {}; template void foo(const A &a) {} void test() { A a; foo(a); } } @ 1.1.1.1.4.1 log @file deduction.cpp was added on branch yamt-pagecache on 2014-05-22 16:19:45 +0000 @ text @d1 164 @ 1.1.1.1.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 164 // RUN: %clang_cc1 -fsyntax-only -verify %s // Template argument deduction with template template parameters. template class A> struct X0 { static const unsigned value = 0; }; template class A> struct X0 { static const unsigned value = 1; }; template struct X0i; template struct X0l; int array_x0a[X0::value == 0? 1 : -1]; int array_x0b[X0::value == 1? 1 : -1]; template struct is_same { static const bool value = false; }; template struct is_same { static const bool value = true; }; template struct allocator { }; template > struct vector {}; // Fun with meta-lambdas! struct _1 {}; struct _2 {}; // Replaces all occurrences of _1 with Arg1 and _2 with Arg2 in T. template struct Replace { typedef T type; }; // Replacement of the whole type. template struct Replace<_1, Arg1, Arg2> { typedef Arg1 type; }; template struct Replace<_2, Arg1, Arg2> { typedef Arg2 type; }; // Replacement through cv-qualifiers template struct Replace { typedef typename Replace::type const type; }; // Replacement of templates template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type> type; }; template class TT, typename T1, typename T2, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, typename Replace::type> type; }; // Just for kicks... template class TT, typename T1, typename Arg1, typename Arg2> struct Replace, Arg1, Arg2> { typedef TT::type, Arg2> type; }; int array0[is_same::type, int>::value? 1 : -1]; int array1[is_same::type, const int>::value? 1 : -1]; int array2[is_same, int, float>::type, vector >::value? 1 : -1]; int array3[is_same, int, float>::type, vector >::value? 1 : -1]; int array4[is_same, double, float>::type, vector >::value? 1 : -1]; // PR5911 template void f(const T (&a)[N]); int iarr[] = { 1 }; void test_PR5911() { f(iarr); } // Must not examine base classes of incomplete type during template argument // deduction. namespace PR6257 { template struct X { template X(const X& u); }; struct A; void f(A& a); void f(const X& a); void test(A& a) { (void)f(a); } } // PR7463 namespace PR7463 { const int f (); template void g (T_&); // expected-note{{T_ = int}} void h (void) { g(f()); } // expected-error{{no matching function for call}} } namespace test0 { template void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'char'}} char *char_maker(); void test() { make(char_maker); // expected-error {{no matching function for call to 'make'}} } } namespace test1 { template void foo(const T a[3][3]); void test() { int a[3][3]; foo(a); } } // PR7708 namespace test2 { template struct Const { typedef void const type; }; template void f(T, typename Const::type*); template void f(T, void const *); void test() { void *p = 0; f(0, p); } } // rdar://problem/8537391 namespace test3 { struct Foo { template static inline void foo(); }; class Bar { template static inline void wobble(T ch); public: static void madness() { Foo::foo >(); } }; } // Verify that we can deduce enum-typed arguments correctly. namespace test14 { enum E { E0, E1 }; template struct A {}; template void foo(const A &a) {} void test() { A a; foo(a); } } @