test/SemaCXX/cxx1y-deduced-return-type.cpp

   1 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
   2 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
   3
   4 auto f(); // expected-note {{previous}}
   5 int f(); // expected-error {{differ only in their return type}}
   6
   7 auto &g();
   8 auto g() -> auto &;
   9
  10 auto h() -> auto *;
  11 auto *h();
  12
  13 struct Conv1 {
  14   operator auto(); // expected-note {{declared here}}
  15 } conv1;
  16 int conv1a = conv1; // expected-error {{function 'operator auto' with deduced return type cannot be used before it is defined}}
  17 // expected-error@-1 {{no viable conversion}}
  18 Conv1::operator auto() { return 123; }
  19 int conv1b = conv1;
  20 int conv1c = conv1.operator auto();
  21 int conv1d = conv1.operator int(); // expected-error {{no member named 'operator int'}}
  22
  23 struct Conv2 {
  24   operator auto() { return 0; }  // expected-note {{previous}}
  25   operator auto() { return 0.; } // expected-error {{cannot be redeclared}} expected-error {{cannot initialize return object of type 'auto' with an rvalue of type 'double'}}
  26 };
  27
  28 struct Conv3 {
  29   operator auto() { int *p = nullptr; return p; }  // expected-note {{candidate}}
  30   operator auto*() { int *p = nullptr; return p; } // expected-note {{candidate}}
  31 } conv3;
  32 int *conv3a = conv3; // expected-error {{ambiguous}}
  33 int *conv3b = conv3.operator auto();
  34 int *conv3c = conv3.operator auto*();
  35
  36 template<typename T>
  37 struct Conv4 {
  38   operator auto() { return T(); }
  39 };
  40 Conv4<int> conv4int;
  41 int conv4a = conv4int;
  42 int conv4b = conv4int.operator auto();
  43
  44 auto a();
  45 auto a() { return 0; }
  46 using T = decltype(a());
  47 using T = int;
  48 auto a(); // expected-note {{previous}}
  49 using T = decltype(a());
  50 auto *a(); // expected-error {{differ only in their return type}}
  51
  52 auto b(bool k) {
  53   if (k)
  54     return "hello";
  55   return "goodbye";
  56 }
  57
  58 auto *ptr_1() {
  59   return 100; // expected-error {{cannot deduce return type 'auto *' from returned value of type 'int'}}
  60 }
  61
  62 const auto &ref_1() {
  63   return 0; // expected-warning {{returning reference to local temporary}}
  64 }
  65
  66 auto init_list() {
  67   return { 1, 2, 3 }; // expected-error {{cannot deduce return type from initializer list}}
  68 }
  69
  70 auto fwd_decl(); // expected-note 2{{here}}
  71
  72 int n = fwd_decl(); // expected-error {{function 'fwd_decl' with deduced return type cannot be used before it is defined}}
  73 int k = sizeof(fwd_decl()); // expected-error {{used before it is defined}}
  74
  75 auto fac(int n) {
  76   if (n <= 2)
  77     return n;
  78   return n * fac(n-1); // ok
  79 }
  80
  81 auto fac_2(int n) { // expected-note {{declared here}}
  82   if (n > 2)
  83     return n * fac_2(n-1); // expected-error {{cannot be used before it is defined}}
  84   return n;
  85 }
  86
  87 auto void_ret() {}
  88 using Void = void;
  89 using Void = decltype(void_ret());
  90
  91 auto &void_ret_2() {} // expected-error {{cannot deduce return type 'auto &' for function with no return statements}}
  92 const auto void_ret_3() {} // ok, return type 'const void' is adjusted to 'void'
  93
  94 const auto void_ret_4() {
  95   if (false)
  96     return void();
  97   if (false)
  98     return;
  99   return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}
 100 }
 101
 102 namespace Templates {
 103   template<typename T> auto f1() {
 104     return T() + 1;
 105   }
 106   template<typename T> auto &f2(T &&v) { return v; }
 107   int a = f1<int>();
 108   const int &b = f2(0);
 109   double d;
 110   float &c = f2(0.0); // expected-error {{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'double'}}
 111
 112   template<typename T> auto fwd_decl(); // expected-note {{declared here}}
 113   int e = fwd_decl<int>(); // expected-error {{cannot be used before it is defined}}
 114   template<typename T> auto fwd_decl() { return 0; }
 115   int f = fwd_decl<int>();
 116   template <typename T>
 117   auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}
 118   int g = fwd_decl<char>();
 119
 120   auto (*p)() = f1; // expected-error {{incompatible initializer}}
 121   auto (*q)() = f1<int>; // ok
 122
 123   typedef decltype(f2(1.2)) dbl; // expected-note {{previous}}
 124   typedef float dbl; // expected-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}
 125
 126   extern template auto fwd_decl<double>();
 127   int k1 = fwd_decl<double>();
 128   extern template int fwd_decl<char>(); // expected-error {{does not refer to a function template}}
 129   int k2 = fwd_decl<char>();
 130
 131   template <typename T> auto instantiate() { T::error; } // expected-error {{has no members}} \
 132     // expected-note {{candidate template ignored: could not match 'auto ()' against 'void ()'}}
 133   extern template auto instantiate<int>(); // ok
 134   int k = instantiate<int>(); // expected-note {{in instantiation of}}
 135   template<> auto instantiate<char>() {} // ok
 136   template<> void instantiate<double>() {} // expected-error {{no function template matches}}
 137
 138   template<typename T> auto arg_single() { return 0; }
 139   template<typename T> auto arg_multi() { return 0l; }
 140   template<typename T> auto arg_multi(int) { return "bad"; }
 141   template<typename T> struct Outer {
 142     static auto arg_single() { return 0.f; }
 143     static auto arg_multi() { return 0.; }
 144     static auto arg_multi(int) { return "bad"; }
 145   };
 146   template<typename T> T &take_fn(T (*p)());
 147
 148   int &check1 = take_fn(arg_single); // expected-error {{no matching}} expected-note@-2 {{couldn't infer}}
 149   int &check2 = take_fn(arg_single<int>);
 150   int &check3 = take_fn<int>(arg_single); // expected-error {{no matching}} expected-note@-4{{no overload of 'arg_single'}}
 151   int &check4 = take_fn<int>(arg_single<int>);
 152   long &check5 = take_fn(arg_multi); // expected-error {{no matching}} expected-note@-6 {{couldn't infer}}
 153   long &check6 = take_fn(arg_multi<int>);
 154   long &check7 = take_fn<long>(arg_multi); // expected-error {{no matching}} expected-note@-8{{no overload of 'arg_multi'}}
 155   long &check8 = take_fn<long>(arg_multi<int>);
 156
 157   float &mem_check1 = take_fn(Outer<int>::arg_single);
 158   float &mem_check2 = take_fn<float>(Outer<char>::arg_single);
 159   double &mem_check3 = take_fn(Outer<long>::arg_multi);
 160   double &mem_check4 = take_fn<double>(Outer<double>::arg_multi);
 161
 162   namespace Deduce1 {
 163   template <typename T> auto f() { return 0; } // expected-note {{couldn't infer template argument 'T'}}
 164     template<typename T> void g(T(*)()); // expected-note 2{{candidate}}
 165     void h() {
 166       auto p = f<int>;
 167       auto (*q)() = f<int>;
 168       int (*r)() = f; // expected-error {{does not match}}
 169       g(f<int>);
 170       g<int>(f); // expected-error {{no matching function}}
 171       g(f); // expected-error {{no matching function}}
 172     }
 173   }
 174
 175   namespace Deduce2 {
 176   template <typename T> auto f(int) { return 0; } // expected-note {{couldn't infer template argument 'T'}}
 177     template<typename T> void g(T(*)(int)); // expected-note 2{{candidate}}
 178     void h() {
 179       auto p = f<int>;
 180       auto (*q)(int) = f<int>;
 181       int (*r)(int) = f; // expected-error {{does not match}}
 182       g(f<int>);
 183       g<int>(f); // expected-error {{no matching function}}
 184       g(f); // expected-error {{no matching function}}
 185     }
 186   }
 187
 188   namespace Deduce3 {
 189     template<typename T> auto f(T) { return 0; }
 190     template<typename T> void g(T(*)(int)); // expected-note {{couldn't infer}}
 191     void h() {
 192       auto p = f<int>;
 193       auto (*q)(int) = f<int>;
 194       int (*r)(int) = f; // ok
 195       g(f<int>);
 196       g<int>(f); // ok
 197       g(f); // expected-error {{no matching function}}
 198     }
 199   }
 200
 201   namespace DeduceInDeducedReturnType {
 202     template<typename T, typename U> auto f() -> auto (T::*)(U) {
 203       int (T::*result)(U) = nullptr;
 204       return result;
 205     }
 206     struct S {};
 207     int (S::*(*p)())(double) = f;
 208     int (S::*(*q)())(double) = f<S, double>;
 209   }
 210 }
 211
 212 auto fwd_decl_using();
 213 namespace N { using ::fwd_decl_using; }
 214 auto fwd_decl_using() { return 0; }
 215 namespace N { int k = N::fwd_decl_using(); }
 216
 217 namespace OverloadResolutionNonTemplate {
 218   auto f();
 219   auto f(int); // expected-note {{here}}
 220
 221   int &g(int (*f)()); // expected-note {{not viable: no overload of 'f' matching 'int (*)()'}}
 222   char &g(int (*f)(int)); // expected-note {{not viable: no overload of 'f' matching 'int (*)(int)'}}
 223
 224   int a = g(f); // expected-error {{no matching function}}
 225
 226   auto f() { return 0; }
 227
 228   // FIXME: It's not completely clear whether this should be ill-formed.
 229   int &b = g(f); // expected-error {{used before it is defined}}
 230
 231   auto f(int) { return 0.0; }
 232
 233   int &c = g(f); // ok
 234 }
 235
 236 namespace OverloadResolutionTemplate {
 237   auto f();
 238   template<typename T> auto f(T);
 239
 240   int &g(int (*f)()); // expected-note {{not viable: no overload of 'f' matching 'int (*)()'}} expected-note {{candidate}}
 241   char &g(int (*f)(int)); // expected-note {{not viable: no overload of 'f' matching 'int (*)(int)'}} expected-note {{candidate}}
 242
 243   int a = g(f); // expected-error {{no matching function}}
 244
 245   auto f() { return 0; }
 246
 247   int &b = g(f); // ok (presumably), due to deduction failure forming type of 'f<int>'
 248
 249   template<typename T> auto f(T) { return 0; }
 250
 251   int &c = g(f); // expected-error {{ambiguous}}
 252 }
 253
 254 namespace DefaultedMethods {
 255   struct A {
 256     auto operator=(const A&) = default; // expected-error {{must return 'DefaultedMethods::A &'}}
 257     A &operator=(A&&); // expected-note {{previous}}
 258   };
 259   auto A::operator=(A&&) = default; // expected-error {{return type of out-of-line definition of 'DefaultedMethods::A::operator=' differs from that in the declaration}}
 260 }
 261
 262 namespace Constexpr {
 263   constexpr auto f1(int n) { return n; }
 264   template<typename T> struct X { constexpr auto f() {} }; // PR18746
 265   template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}
 266   void f() {
 267     X<int>().f();
 268     Y<void>().f();
 269     constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}}
 270   }
 271   struct NonLiteral { ~NonLiteral(); } nl; // expected-note {{user-provided destructor}}
 272   constexpr auto f2(int n) { return nl; } // expected-error {{return type 'Constexpr::NonLiteral' is not a literal type}}
 273 }
 274
 275 // It's not really clear whether these are valid, but this matches g++.
 276 using size_t = decltype(sizeof(0));
 277 auto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}}
 278 auto operator delete(void *, const char*); // expected-error {{must return type 'void'}}
 279
 280 namespace Virtual {
 281   struct S {
 282     virtual auto f() { return 0; } // expected-error {{function with deduced return type cannot be virtual}} expected-note {{here}}
 283   };
 284   // Allow 'auto' anyway for error recovery.
 285   struct T : S {
 286     int f();
 287   };
 288   struct U : S {
 289     auto f(); // expected-error {{different return}}
 290   };
 291
 292   // And here's why...
 293   struct V { virtual auto f(); }; // expected-error {{cannot be virtual}}
 294   struct W : V { virtual auto f(); }; // expected-error {{cannot be virtual}}
 295   auto V::f() { return 0; } // in tu1.cpp
 296   auto W::f() { return 0.0; } // in tu2.cpp
 297   W w;
 298   int k1 = w.f();
 299   int k2 = ((V&)w).f();
 300 }
 301
 302 namespace std_examples {
 303
 304 namespace NoReturn {
 305   auto f() {}
 306   void (*p)() = &f;
 307
 308   auto f(); // ok
 309
 310   auto *g() {} // expected-error {{cannot deduce return type 'auto *' for function with no return statements}}
 311
 312   auto h() = delete; // expected-note {{explicitly deleted}}
 313   auto x = h(); // expected-error {{call to deleted}}
 314 }
 315
 316 namespace UseBeforeComplete {
 317   auto n = n; // expected-error {{variable 'n' declared with 'auto' type cannot appear in its own initializer}}
 318   auto f(); // expected-note {{declared here}}
 319   void g() { &f; } // expected-error {{function 'f' with deduced return type cannot be used before it is defined}}
 320   auto sum(int i) {
 321     if (i == 1)
 322       return i;
 323     else
 324       return sum(i - 1) + i;
 325   }
 326 }
 327
 328 namespace Redecl {
 329   auto f();
 330   auto f() { return 42; }
 331   auto f(); // expected-note 2{{previous}}
 332   int f(); // expected-error {{functions that differ only in their return type cannot be overloaded}}
 333   decltype(auto) f(); // expected-error {{cannot be overloaded}}
 334
 335   template <typename T> auto g(T t) { return t; } // expected-note {{candidate}} \
 336                                                   // expected-note {{candidate function [with T = int]}}
 337   template auto g(int);
 338   template char g(char); // expected-error {{does not refer to a function}}
 339   template<> auto g(double);
 340
 341   template<typename T> T g(T t) { return t; } // expected-note {{candidate}}
 342   template char g(char);
 343   template auto g(float);
 344
 345   void h() { return g(42); } // expected-error {{ambiguous}}
 346 }
 347
 348 namespace ExplicitInstantiationDecl {
 349   template<typename T> auto f(T t) { return t; }
 350   extern template auto f(int);
 351   int (*p)(int) = f;
 352 }
 353 namespace MemberTemplatesWithDeduction {
 354   struct M {
 355     template<class T> auto foo(T t) { return t; }
 356     template<class T> auto operator()(T t) const { return t; }
 357     template<class T> static __attribute__((unused)) int static_foo(T) {
 358       return 5;
 359     }
 360     template<class T> operator T() { return T{}; }
 361     operator auto() { return &static_foo<int>; }
 362   };
 363   struct N : M {
 364     using M::foo;
 365     using M::operator();
 366     using M::static_foo;
 367     using M::operator auto;
 368   };
 369
 370   template <class T> int test() {
 371     int i = T{}.foo(3);
 372     T m = T{}.foo(M{});
 373     int j = T{}(3);
 374     M m2 = M{}(M{});
 375     int k = T{}.static_foo(4);
 376     int l = T::static_foo(5);
 377     int l2 = T{};
 378     struct X { };
 379     X x = T{};
 380     return 0;
 381   }
 382   int Minst = test<M>();
 383   int Ninst = test<N>();
 384
 385 }
 386 }
 387
 388 namespace CurrentInstantiation {
 389   // PR16875
 390   template<typename T> struct S {
 391     auto f() { return T(); }
 392     int g() { return f(); }
 393     auto h(bool b) {
 394       if (b)
 395         return T();
 396       return h(true);
 397     }
 398   };
 399   int k1 = S<int>().g();
 400   int k2 = S<int>().h(false);
 401
 402   template<typename T> struct U {
 403  #ifndef DELAYED_TEMPLATE_PARSING
 404     auto f(); // expected-note {{here}}
 405     int g() { return f(); } // expected-error {{cannot be used before it is defined}}
 406  #else
 407     auto f();
 408     int g() { return f(); }
 409  #endif
 410   };
 411  #ifndef DELAYED_TEMPLATE_PARSING
 412   template int U<int>::g(); // expected-note {{in instantiation of}}
 413  #else
 414   template int U<int>::g();
 415  #endif
 416   template<typename T> auto U<T>::f() { return T(); }
 417   template int U<short>::g(); // ok
 418 }
 419
 420 namespace WithDefaultArgs {
 421   template<typename U> struct A {
 422     template<typename T = U> friend auto f(A) { return []{}; }
 423   };
 424   template<typename T> void f();
 425   using T = decltype(f(A<int>()));
 426   using T = decltype(f<int>(A<int>()));
 427 }
 428
 429 namespace MultilevelDeduction {
 430
 431 auto F() -> auto* { return (int*)0; }
 432
 433 auto (*G())() -> int* { return F; }
 434
 435 auto run = G();
 436
 437 namespace Templated {
 438 template<class T>
 439 auto F(T t) -> auto* { return (T*)0; }
 440
 441 template<class T>
 442 auto (*G(T t))(T) -> T* { return &F<T>; }
 443
 444
 445 template<class T>
 446 auto (*G2(T t))(T) -> auto* { return &F<T>; }
 447
 448 auto run_int = G(1);
 449 auto run_char = G2('a');
 450
 451 }
 452 }
 453
 454 namespace rnk {
 455 extern "C" int puts(const char *s);
 456 template <typename T>
 457 auto foo(T x) -> decltype(x) {
 458 #ifdef DELAYED_TEMPLATE_PARSING
 459   ::rnk::bar();
 460 #endif
 461   return x;
 462 }
 463 void bar() { puts("bar"); }
 464 int main() { return foo(0); }
 465
 466 }
 467
 468 namespace OverloadedOperators {
 469   template<typename T> struct A {
 470     auto operator()() { return T{}; }
 471     auto operator[](int) { return T{}; }
 472     auto operator+(int) { return T{}; }
 473     auto operator+() { return T{}; }
 474     friend auto operator-(A) { return T{}; }
 475     friend auto operator-(A, A) { return T{}; }
 476   };
 477   void f(A<int> a) {
 478     int b = a();
 479     int c = a[0];
 480     int d = a + 0;
 481     int e = +a;
 482     int f = -a;
 483     int g = a - a;
 484   }
 485 }
 486
 487 namespace TrailingReturnTypeForConversionOperator {
 488   struct X {
 489     operator auto() -> int { return 0; } // expected-error {{cannot specify any part of a return type in the declaration of a conversion function; put the complete type after 'operator'}}
 490   } x;
 491   int k = x.operator auto();
 492
 493   struct Y {
 494     operator auto() -> int & { // expected-error {{cannot specify}}
 495       return 0; // expected-error {{cannot bind to}}
 496     }
 497   };
 498 };