4 auto f(); // expected-note {{previous}}
7 auto &g();
8 auto g() -> auto &;
10 auto h() -> auto *;
11 auto *h();
14   operator auto(); // expected-note {{declared here}}
16 int conv1a = conv1; // expected-error {{function 'operator auto' with deduced return type cannot be used before it is defined}}
18 Conv1::operator auto() { return 123; }
20 int conv1c = conv1.operator auto();
24   operator auto() { return 0; }  // expected-note 2{{previous}}
25   operator auto() { return 0.; } // expected-error {{cannot be redeclared}} expected-error {{redefinition of 'operator auto'}}
29   operator auto() { int *p = nullptr; return p; }  // expected-note {{candidate}}
30   operator auto*() { int *p = nullptr; return p; } // expected-note {{candidate}}
33 int *conv3b = conv3.operator auto();
34 int *conv3c = conv3.operator auto*();
38   operator auto() { return T(); }
42 int conv4b = conv4int.operator auto();
44 auto a();
45 auto a() { return 0; }
48 auto a(); // expected-note {{previous}}
50 auto *a(); // expected-error {{differ only in their return type}}
52 auto b(bool k) {
58 auto *ptr_1() {
59   return 100; // expected-error {{cannot deduce return type 'auto *' from returned value of type 'int'}}
62 const auto &ref_1() {
66 auto init_list() {
70 auto fwd_decl(); // expected-note 2{{here}}
75 auto fac(int n) {
81 auto fac_2(int n) { // expected-note {{declared here}}
87 auto void_ret() {}
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'
94 const auto void_ret_4() {
99   return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}
103   template<typename T> auto f1() {
106   template<typename T> auto &f2(T &&v) { return v; }
112   template<typename T> auto fwd_decl(); // expected-note {{declared here}}
114   template<typename T> auto fwd_decl() { return 0; }
117   auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}
120   auto (*p)() = f1; // expected-error {{incompatible initializer}}
121   auto (*q)() = f1<int>; // ok
126   extern template auto fwd_decl<double>();
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
135   template<> auto instantiate<char>() {} // ok
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"; }
142     static auto arg_single() { return 0.f; }
143     static auto arg_multi() { return 0.; }
144     static auto arg_multi(int) { return "bad"; }
163   template <typename T> auto f() { return 0; } // expected-note {{couldn't infer template argument 'T'}}
166       auto p = f<int>;
167       auto (*q)() = f<int>;
176   template <typename T> auto f(int) { return 0; } // expected-note {{couldn't infer template argument 'T'}}
179       auto p = f<int>;
180       auto (*q)(int) = f<int>;
189     template<typename T> auto f(T) { return 0; }
192       auto p = f<int>;
193       auto (*q)(int) = f<int>;
202     template<typename T, typename U> auto f() -> auto (T::*)(U) {
212 auto fwd_decl_using();
214 auto fwd_decl_using() { return 0; }
218   auto f();
219   auto f(int); // expected-note {{here}}
226   auto f() { return 0; }
231   auto f(int) { return 0.0; }
237   auto f();
238   template<typename T> auto f(T);
245   auto f() { return 0; }
249   template<typename T> auto f(T) { return 0; }
256     auto operator=(const A&) = default; // expected-error {{must return 'DefaultedMethods::A &'}}
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}}
263   constexpr auto f1(int n) { return n; }
264   template<typename T> struct X { constexpr auto f() {} }; // PR18746
272   constexpr auto f2(int n) { return nl; } // expected-error {{return type 'Constexpr::NonLiteral' is not a literal type}}
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'}}
282     virtual auto f() { return 0; } // expected-error {{function with deduced return type cannot be virtual}} expected-note {{here}}
284   // Allow 'auto' anyway for error recovery.
289     auto f(); // expected-error {{different return}}
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
305   auto f() {}
308   auto f(); // ok
310   auto *g() {} // expected-error {{cannot deduce return type 'auto *' for function with no return statements}}
312   auto h() = delete; // expected-note {{explicitly deleted}}
313   auto x = h(); // expected-error {{call to deleted}}
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}}
320   auto sum(int i) {
329   auto f();
330   auto f() { return 42; }
331   auto f(); // expected-note 2{{previous}}
333   decltype(auto) f(); // expected-error {{cannot be overloaded}}
335   template <typename T> auto g(T t) { return t; } // expected-note {{candidate}} \
337   template auto g(int);
339   template<> auto g(double);
343   template auto g(float);
349   template<typename T> auto f(T t) { return t; }
350   extern template auto f(int);
355     template<class T> auto foo(T t) { return t; }
356     template<class T> auto operator()(T t) const { return t; }
361     operator auto() { return &static_foo<int>; } 
367     using M::operator auto;
391     auto f() { return T(); }
393     auto h(bool b) {
404     auto f(); // expected-note {{here}}
407     auto f(); 
416   template<typename T> auto U<T>::f() { return T(); }
422     template<typename T = U> friend auto f(A) { return []{}; }
431 auto F() -> auto* { return (int*)0; }
433 auto (*G())() -> int* { return F; }
435 auto run = G();
439 auto F(T t) -> auto* { return (T*)0; }
442 auto (*G(T t))(T) -> T* { return &F<T>; }
446 auto (*G2(T t))(T) -> auto* { return &F<T>; }
448 auto run_int = G(1);
449 auto run_char = G2('a');
457 auto foo(T x) -> decltype(x) {
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{}; }

Indexes created Fri Mar 13 02:32:08 CET 2015