clang/test/SemaTemplate/overload-candidates.cpp

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