1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2
3 template<typename T>
4 const T& min(const T&, const T&); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'long')}}
5
test_min()6 void test_min() {
7 (void)min(1, 2l); // expected-error{{no matching function for call to 'min'}}
8 }
9
10 template<typename R, typename T>
11 R *dyn_cast(const T&); // expected-note{{candidate template ignored: couldn't infer template argument 'R'}}
12
test_dyn_cast(int * ptr)13 void test_dyn_cast(int* ptr) {
14 (void)dyn_cast(ptr); // expected-error{{no matching function for call to 'dyn_cast'}}
15 }
16
17 template<int I, typename T>
18 void get(const T&); // expected-note{{candidate template ignored: invalid explicitly-specified argument for template parameter 'I'}}
19 template<template<class T> class, typename T>
20 void get(const T&); // expected-note{{candidate template ignored: invalid explicitly-specified argument for 1st template parameter}}
21
test_get(void * ptr)22 void test_get(void *ptr) {
23 get<int>(ptr); // expected-error{{no matching function for call to 'get'}}
24 }
25
26 template<typename T>
27 typename T::type get_type(const T&); // expected-note{{candidate template ignored: substitution failure [with T = int *]: type 'int *' cannot be used prior to '::'}}
28 template<typename T>
29 void get_type(T *, int[(int)sizeof(T) - 9] = 0); // expected-note{{candidate template ignored: substitution failure [with T = int]: array size is negative}}
30
test_get_type(int * ptr)31 void test_get_type(int *ptr) {
32 (void)get_type(ptr); // expected-error{{no matching function for call to 'get_type'}}
33 }
34
35 struct X {
36 template<typename T>
37 const T& min(const T&, const T&); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'long')}}
38 };
39
test_X_min(X x)40 void test_X_min(X x) {
41 (void)x.min(1, 2l); // expected-error{{no matching member function for call to 'min'}}
42 }
43
44 namespace boost {
45 template<bool, typename = void> struct enable_if {};
46 template<typename T> struct enable_if<true, T> { typedef T type; };
47 }
48 template<typename T> typename boost::enable_if<sizeof(T) == 4, int>::type if_size_4(); // expected-note{{candidate template ignored: disabled by 'enable_if' [with T = char]}}
49 int k = if_size_4<char>(); // expected-error{{no matching function}}
50
51 namespace llvm {
52 template<typename Cond, typename T = void> struct enable_if : boost::enable_if<Cond::value, T> {};
53 }
54 template<typename T> struct is_int { enum { value = false }; };
55 template<> struct is_int<int> { enum { value = true }; };
56 template<typename T> typename llvm::enable_if<is_int<T> >::type if_int(); // expected-note{{candidate template ignored: disabled by 'enable_if' [with T = char]}}
test_if_int()57 void test_if_int() {
58 if_int<char>(); // expected-error{{no matching function}}
59 }
60
61 template<typename T> struct NonTemplateFunction {
62 typename boost::enable_if<sizeof(T) == 4, int>::type f(); // expected-error{{no type named 'type' in 'boost::enable_if<false, int>'; 'enable_if' cannot be used to disable this declaration}}
63 };
64 NonTemplateFunction<char> NTFC; // expected-note{{here}}
65
66 namespace NS1 {
67 template <class A>
68 class array {};
69 }
70
71 namespace NS2 {
72 template <class A>
73 class array {};
74 }
75
76 template <class A>
77 void foo(NS2::array<A>); // expected-note{{candidate template ignored: could not match 'NS2::array' against 'NS1::array'}}
78
test()79 void test() {
80 foo(NS1::array<int>()); // expected-error{{no matching function for call to 'foo'}}
81 }
82
83 namespace std {
84 template<bool, typename = void> struct enable_if {};
85 template<typename T> struct enable_if<true, T> { typedef T type; };
86
87 template<typename T, T V> struct integral_constant { static const T value = V; };
88 typedef integral_constant<bool, false> false_type;
89 typedef integral_constant<bool, true> true_type;
90 };
91
92 namespace PR15673 {
93 template<typename T>
94 struct a_trait : std::false_type {};
95
96 template<typename T,
97 typename Requires = typename std::enable_if<a_trait<T>::value>::type> // expected-warning {{C++11 extension}}
98 // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
foo()99 void foo() {}
bar()100 void bar() { foo<int>(); } // expected-error {{no matching function for call to 'foo'}}
101
102
103 template<typename T>
104 struct some_trait : std::false_type {};
105
106 // FIXME: It would be nice to tunnel the 'disabled by enable_if' diagnostic through here.
107 template<typename T>
108 struct a_pony : std::enable_if<some_trait<T>::value> {};
109
110 template<typename T,
111 typename Requires = typename a_pony<T>::type> // expected-warning {{C++11 extension}}
112 // FIXME: The source location here is poor.
baz()113 void baz() { } // expected-note {{candidate template ignored: substitution failure [with T = int]: no type named 'type' in 'PR15673::a_pony<int>'}}
quux()114 void quux() { baz<int>(); } // expected-error {{no matching function for call to 'baz'}}
115
116
117 // FIXME: This note doesn't make it clear which candidate we rejected.
118 template <typename T>
119 using unicorns = typename std::enable_if<some_trait<T>::value>::type; // expected-warning {{C++11 extension}}
120 // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
121
122 template<typename T,
123 typename Requires = unicorns<T> > // expected-warning {{C++11 extension}}
wibble()124 void wibble() {}
wobble()125 void wobble() { wibble<int>(); } // expected-error {{no matching function for call to 'wibble'}}
126 }
127