{"owner":"nuudlman","repo":"llvm","channel":"main","channels":["main"],"can_delete":true,"inode":{"File":{"path":[{"basename":"clang","pos":"7OVOGA6QKF5OI.EJBFAJQ","meta":576},{"basename":"test","pos":"7OVOGA6QKF5OI.RXSO6JQ","meta":576},{"basename":"SemaCXX","pos":"7OVOGA6QKF5OI.HPUBWJY","meta":576},{"basename":"deduced-return-type-cxx14.cpp","pos":"7OVOGA6QKF5OI.6TXD6JY","meta":0}],"file":"// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s\n// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING\n\n// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s\n// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING\n\n// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s\n// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING\n\nauto f(); // expected-note {{previous}}\nint f(); // expected-error {{differ only in their return type}}\n\nauto &g();\nauto g() -> auto &;\n\nauto h() -> auto *;\nauto *h();\n\nstruct Conv1 {\n operator auto(); // expected-note {{declared here}}\n} conv1;\nint conv1a = conv1; // expected-error {{function 'operator auto' with deduced return type cannot be used before it is defined}}\n// expected-error@-1 {{no viable conversion}}\nConv1::operator auto() { return 123; }\nint conv1b = conv1;\nint conv1c = conv1.operator auto();\nint conv1d = conv1.operator int(); // expected-error {{no member named 'operator int'}}\n\nstruct Conv2 {\n operator auto() { return 0; } // expected-note {{previous}}\n operator auto() { return 0.; } // expected-error {{cannot be redeclared}}\n};\n\nstruct Conv3 {\n operator auto() { int *p = nullptr; return p; } // expected-note {{candidate}}\n operator auto*() { int *p = nullptr; return p; } // expected-note {{candidate}}\n} conv3;\nint *conv3a = conv3; // expected-error {{ambiguous}}\nint *conv3b = conv3.operator auto();\nint *conv3c = conv3.operator auto*();\n\ntemplate\nstruct Conv4 {\n operator auto() { return T(); }\n};\nConv4 conv4int;\nint conv4a = conv4int;\nint conv4b = conv4int.operator auto();\n\nauto a();\nauto a() { return 0; }\nusing T = decltype(a());\nusing T = int;\nauto a(); // expected-note {{previous}}\nusing T = decltype(a());\nauto *a(); // expected-error {{differ only in their return type}}\n\nauto b(bool k) {\n if (k)\n return \"hello\";\n return \"goodbye\";\n}\n\n// Allow 'operator auto' to call only the explicit operator auto.\nstruct BothOps {\n template operator T();\n template operator T *();\n operator auto() { return 0; }\n operator auto *() { return this; }\n};\nstruct JustTemplateOp {\n template operator T();\n template operator T *();\n};\n\nauto c() {\n BothOps().operator auto(); // ok\n BothOps().operator auto *(); // ok\n JustTemplateOp().operator auto(); // expected-error {{no member named 'operator auto' in 'JustTemplateOp'}}\n JustTemplateOp().operator auto *(); // expected-error {{no member named 'operator auto *' in 'JustTemplateOp'}}\n}\n\nauto *ptr_1() {\n return 100; // expected-error {{cannot deduce return type 'auto *' from returned value of type 'int'}}\n}\n\nconst auto &ref_1() {\n return 0; // expected-warning {{returning reference to local temporary}}\n}\n\nauto init_list() {\n return { 1, 2, 3 }; // expected-error {{cannot deduce return type from initializer list}}\n}\n\nauto fwd_decl(); // expected-note 2{{here}}\n\nint n = fwd_decl(); // expected-error {{function 'fwd_decl' with deduced return type cannot be used before it is defined}}\nint k = sizeof(fwd_decl()); // expected-error {{used before it is defined}}\n\nauto fac(int n) {\n if (n <= 2)\n return n;\n return n * fac(n-1); // ok\n}\n\nauto fac_2(int n) { // expected-note {{declared here}}\n if (n > 2)\n return n * fac_2(n-1); // expected-error {{cannot be used before it is defined}}\n return n;\n}\n\nauto void_ret() {}\nusing Void = void;\nusing Void = decltype(void_ret());\n\nauto &void_ret_2() {} // expected-error {{cannot deduce return type 'auto &' for function with no return statements}}\nconst auto void_ret_3() {} // ok, return type 'const void' is adjusted to 'void'\n\nconst auto void_ret_4() {\n if (false)\n return void();\n if (false)\n return;\n return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}\n}\n\nnamespace Templates {\n template auto f1() {\n return T() + 1;\n }\n template auto &f2(T &&v) { return v; }\n // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}\n // cxx2b-error@-2 {{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}}\n // cxx2b-note@-3 {{candidate template ignored: substitution failure [with T = double]}}\n int a = f1();\n const int &b = f2(0); // cxx2b-note {{in instantiation of function template specialization 'Templates::f2' requested here}}\n double d;\n float &c = f2(0.0); // expected-error {{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'double'}}\n // cxx2b-note@-1 {{in instantiation of function template specialization 'Templates::f2' requested here}}\n\n template auto fwd_decl(); // expected-note {{declared here}}\n int e = fwd_decl(); // expected-error {{cannot be used before it is defined}}\n template auto fwd_decl() { return 0; }\n int f = fwd_decl();\n template \n auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}\n int g = fwd_decl();\n\n auto (*p)() = f1; // expected-error {{variable 'p' with type 'auto (*)()' has incompatible initializer of type ''}}\n auto (*q)() = f1; // ok\n\n typedef decltype(f2(1.2)) dbl; // cxx14_20-note {{previous}}\n // cxx2b-error@-1 {{no matching function for call to 'f2'}}\n typedef float dbl; // cxx14_20-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}\n\n extern template auto fwd_decl();\n int k1 = fwd_decl();\n extern template int fwd_decl(); // expected-error {{does not refer to a function template}}\n int k2 = fwd_decl();\n\n template auto instantiate() { T::error; } // expected-error {{has no members}} \\\n // expected-note {{candidate template ignored: could not match 'auto ()' against 'void ()'}}\n extern template auto instantiate(); // ok\n int k = instantiate(); // expected-note {{in instantiation of}}\n template<> auto instantiate() {} // ok\n template<> void instantiate() {} // expected-error {{no function template matches}}\n\n template auto arg_single() { return 0; }\n template auto arg_multi() { return 0l; }\n template auto arg_multi(int) { return \"bad\"; }\n template struct Outer {\n static auto arg_single() { return 0.f; }\n static auto arg_multi() { return 0.; }\n static auto arg_multi(int) { return \"bad\"; }\n };\n template T &take_fn(T (*p)());\n\n int &check1 = take_fn(arg_single); // expected-error {{no matching}} expected-note@-2 {{couldn't infer}}\n int &check2 = take_fn(arg_single);\n int &check3 = take_fn(arg_single); // expected-error {{no matching}} expected-note@-4{{no overload of 'arg_single'}}\n int &check4 = take_fn(arg_single);\n long &check5 = take_fn(arg_multi); // expected-error {{no matching}} expected-note@-6 {{couldn't infer}}\n long &check6 = take_fn(arg_multi);\n long &check7 = take_fn(arg_multi); // expected-error {{no matching}} expected-note@-8{{no overload of 'arg_multi'}}\n long &check8 = take_fn(arg_multi);\n\n float &mem_check1 = take_fn(Outer::arg_single);\n float &mem_check2 = take_fn(Outer::arg_single);\n double &mem_check3 = take_fn(Outer::arg_multi);\n double &mem_check4 = take_fn(Outer::arg_multi);\n\n namespace Deduce1 {\n template auto f() { return 0; } // expected-note {{couldn't infer template argument 'T'}}\n template void g(T(*)()); // expected-note 2{{candidate}}\n void h() {\n auto p = f;\n auto (*q)() = f;\n int (*r)() = f; // expected-error {{does not match}}\n g(f);\n g(f); // expected-error {{no matching function}}\n g(f); // expected-error {{no matching function}}\n }\n }\n\n namespace Deduce2 {\n template auto f(int) { return 0; } // expected-note {{couldn't infer template argument 'T'}}\n template void g(T(*)(int)); // expected-note 2{{candidate}}\n void h() {\n auto p = f;\n auto (*q)(int) = f;\n int (*r)(int) = f; // expected-error {{does not match}}\n g(f);\n g(f); // expected-error {{no matching function}}\n g(f); // expected-error {{no matching function}}\n }\n }\n\n namespace Deduce3 {\n template auto f(T) { return 0; }\n template void g(T(*)(int)); // expected-note {{couldn't infer}}\n void h() {\n auto p = f;\n auto (*q)(int) = f;\n int (*r)(int) = f; // ok\n g(f);\n g(f); // ok\n g(f); // expected-error {{no matching function}}\n }\n }\n\n namespace DeduceInDeducedReturnType {\n template auto f() -> auto (T::*)(U) {\n int (T::*result)(U) = nullptr;\n return result;\n }\n struct S {};\n int (S::*(*p)())(double) = f;\n int (S::*(*q)())(double) = f;\n }\n}\n\nauto fwd_decl_using();\nnamespace N { using ::fwd_decl_using; }\nauto fwd_decl_using() { return 0; }\nnamespace N { int k = N::fwd_decl_using(); }\n\nnamespace OverloadResolutionNonTemplate {\n auto f();\n auto f(int); // expected-note {{here}}\n\n int &g(int (*f)()); // expected-note {{not viable: no overload of 'f' matching 'int (*)()'}}\n char &g(int (*f)(int)); // expected-note {{not viable: no overload of 'f' matching 'int (*)(int)'}}\n\n int a = g(f); // expected-error {{no matching function}}\n\n auto f() { return 0; }\n\n // FIXME: It's not completely clear whether this should be ill-formed.\n int &b = g(f); // expected-error {{used before it is defined}}\n\n auto f(int) { return 0.0; }\n\n int &c = g(f); // ok\n}\n\nnamespace OverloadResolutionTemplate {\n auto f();\n template auto f(T);\n\n int &g(int (*f)()); // expected-note {{not viable: no overload of 'f' matching 'int (*)()'}} expected-note {{candidate}}\n char &g(int (*f)(int)); // expected-note {{not viable: no overload of 'f' matching 'int (*)(int)'}} expected-note {{candidate}}\n\n int a = g(f); // expected-error {{no matching function}}\n\n auto f() { return 0; }\n\n int &b = g(f); // ok (presumably), due to deduction failure forming type of 'f'\n\n template auto f(T) { return 0; }\n\n int &c = g(f); // expected-error {{ambiguous}}\n}\n\nnamespace DefaultedMethods {\n struct A {\n auto operator=(const A&) = default; // expected-error {{must return 'DefaultedMethods::A &'}}\n A &operator=(A&&); // expected-note {{previous}}\n };\n auto A::operator=(A&&) = default; // expected-error {{return type of out-of-line definition of 'DefaultedMethods::A::operator=' differs from that in the declaration}}\n}\n\nnamespace Constexpr {\n constexpr auto f1(int n) { return n; }\n template struct X { constexpr auto f() {} }; // PR18746\n template struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}\n void f() {\n X().f();\n Y().f();\n constexpr int q = Y().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y()->f()'}}\n }\n struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}}\n // cxx20_2b-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}}\n constexpr auto f2(int n) { return nl; } // expected-error {{return type 'struct NonLiteral' is not a literal type}}\n}\n\n// It's not really clear whether these are valid, but this matches g++.\nusing size_t = decltype(sizeof(0));\nauto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}}\nauto operator delete(void *, const char*); // expected-error {{must return type 'void'}}\n\nnamespace Virtual {\n struct S {\n virtual auto f() { return 0; } // expected-error {{function with deduced return type cannot be virtual}} expected-note {{here}}\n };\n // Allow 'auto' anyway for error recovery.\n struct T : S {\n int f();\n };\n struct U : S {\n auto f(); // expected-error {{different return}}\n };\n\n // And here's why...\n struct V { virtual auto f(); }; // expected-error {{cannot be virtual}}\n struct W : V { virtual auto f(); }; // expected-error {{cannot be virtual}}\n auto V::f() { return 0; } // in tu1.cpp\n auto W::f() { return 0.0; } // in tu2.cpp\n W w;\n int k1 = w.f();\n int k2 = ((V&)w).f();\n}\n\nnamespace std_examples {\n\nnamespace NoReturn {\n auto f() {}\n void (*p)() = &f;\n\n auto f(); // ok\n\n auto *g() {} // expected-error {{cannot deduce return type 'auto *' for function with no return statements}}\n\n auto h() = delete; // expected-note {{explicitly deleted}}\n auto x = h(); // expected-error {{call to deleted}}\n}\n\nnamespace UseBeforeComplete {\n auto n = n; // expected-error {{variable 'n' declared with deduced type 'auto' cannot appear in its own initializer}}\n auto f(); // expected-note {{declared here}}\n void g() { &f; } // expected-error {{function 'f' with deduced return type cannot be used before it is defined}}\n auto sum(int i) {\n if (i == 1)\n return i;\n else\n return sum(i - 1) + i;\n }\n}\n\nnamespace Redecl {\n auto f();\n auto f() { return 42; }\n auto f(); // expected-note 2{{previous}}\n int f(); // expected-error {{functions that differ only in their return type cannot be overloaded}}\n decltype(auto) f(); // expected-error {{cannot be overloaded}}\n\n template auto g(T t) { return t; } // expected-note {{candidate}} \\\n // expected-note {{candidate function [with T = int]}}\n template auto g(int);\n template char g(char); // expected-error {{does not refer to a function}}\n template<> auto g(double);\n\n template T g(T t) { return t; } // expected-note {{candidate}}\n template char g(char);\n template auto g(float);\n\n void h() { return g(42); } // expected-error {{ambiguous}}\n}\n\nnamespace ExplicitInstantiationDecl {\n template auto f(T t) { return t; }\n extern template auto f(int);\n int (*p)(int) = f;\n}\nnamespace MemberTemplatesWithDeduction {\n struct M {\n template auto foo(T t) { return t; }\n template auto operator()(T t) const { return t; }\n template static __attribute__((unused)) int static_foo(T) {\n return 5;\n }\n template operator T() { return T{}; }\n operator auto() { return &static_foo; }\n };\n struct N : M {\n using M::foo;\n using M::operator();\n using M::static_foo;\n using M::operator auto;\n };\n\n template int test() {\n int i = T{}.foo(3);\n T m = T{}.foo(M{});\n int j = T{}(3);\n M m2 = M{}(M{});\n int k = T{}.static_foo(4);\n int l = T::static_foo(5);\n int l2 = T{};\n struct X { };\n X x = T{};\n return 0;\n }\n int Minst = test();\n int Ninst = test();\n\n}\n}\n\n// We resolve a wording bug here: 'decltype(auto)' should not be modeled as a\n// decltype-specifier, just as a simple-type-specifier. All the extra places\n// where a decltype-specifier can appear make no sense for 'decltype(auto)'.\nnamespace DecltypeAutoShouldNotBeADecltypeSpecifier {\n namespace NNS {\n int n;\n decltype(auto) i();\n decltype(n) j();\n struct X {\n friend decltype(auto) ::DecltypeAutoShouldNotBeADecltypeSpecifier::NNS::i();\n friend decltype(n) ::DecltypeAutoShouldNotBeADecltypeSpecifier::NNS::j(); // expected-error {{not a class}}\n };\n }\n\n namespace Dtor {\n struct A {};\n void f(A a) { a.~decltype(auto)(); } // expected-error {{'decltype(auto)' not allowed here}}\n void g(int i) { i.~decltype(auto)(); } // expected-error {{'decltype(auto)' not allowed here}}\n }\n\n namespace BaseClass {\n struct A : decltype(auto) {}; // expected-error {{'decltype(auto)' not allowed here}}\n struct B {\n B() : decltype(auto)() {} // expected-error {{'decltype(auto)' not allowed here}}\n };\n }\n}\n\nnamespace CurrentInstantiation {\n // PR16875\n template struct S {\n auto f() { return T(); }\n int g() { return f(); }\n auto h(bool b) {\n if (b)\n return T();\n return h(true);\n }\n };\n int k1 = S().g();\n int k2 = S().h(false);\n\n template struct U {\n #ifndef DELAYED_TEMPLATE_PARSING\n auto f(); // expected-note {{here}}\n int g() { return f(); } // expected-error {{cannot be used before it is defined}}\n #else\n auto f();\n int g() { return f(); }\n #endif\n };\n #ifndef DELAYED_TEMPLATE_PARSING\n template int U::g(); // expected-note {{in instantiation of}}\n #else\n template int U::g();\n #endif\n template auto U::f() { return T(); }\n template int U::g(); // ok\n}\n\nnamespace WithDefaultArgs {\n template struct A {\n template friend auto f(A) { return []{}; }\n };\n template void f();\n using T = decltype(f(A()));\n using T = decltype(f(A()));\n}\n\nnamespace MultilevelDeduction {\n\nauto F() -> auto* { return (int*)0; }\n\nauto (*G())() -> int* { return F; }\n\nauto run = G();\n\nnamespace Templated {\ntemplate\nauto F(T t) -> auto* { return (T*)0; }\n\ntemplate\nauto (*G(T t))(T) -> T* { return &F; }\n\n\ntemplate\nauto (*G2(T t))(T) -> auto* { return &F; }\n\nauto run_int = G(1);\nauto run_char = G2('a');\n\n}\n}\n\nnamespace rnk {\nextern \"C\" int puts(const char *s);\ntemplate \nauto foo(T x) -> decltype(x) {\n#ifdef DELAYED_TEMPLATE_PARSING\n ::rnk::bar();\n#endif\n return x;\n}\nvoid bar() { puts(\"bar\"); }\nint main() { return foo(0); }\n\n}\n\nnamespace OverloadedOperators {\n template struct A {\n auto operator()() { return T{}; }\n auto operator[](int) { return T{}; }\n auto operator+(int) { return T{}; }\n auto operator+() { return T{}; }\n friend auto operator-(A) { return T{}; }\n friend auto operator-(A, A) { return T{}; }\n };\n void f(A a) {\n int b = a();\n int c = a[0];\n int d = a + 0;\n int e = +a;\n int f = -a;\n int g = a - a;\n }\n}\n\nnamespace TrailingReturnTypeForConversionOperator {\n struct X {\n 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'}}\n } x;\n int k = x.operator auto();\n\n struct Y {\n operator auto() -> int & { // expected-error {{cannot specify}}\n return 0; // expected-error {{cannot bind to}}\n }\n };\n};\n\nnamespace PR24989 {\n auto x = [](auto){};\n using T = decltype(x);\n void (T::*p)(int) const = &T::operator();\n}\n\nvoid forinit_decltypeauto() {\n for (decltype(auto) forinit_decltypeauto_inner();;) {} // expected-warning {{interpreted as a function}} expected-note {{replace}}\n}\n\nnamespace PR33222 {\n auto f1();\n auto f2();\n\n template decltype(auto) g0(T x) { return x.n; }\n template decltype(auto) g1(T);\n template decltype(auto) g2(T);\n\n struct X {\n static auto f1();\n static auto f2();\n\n template static decltype(auto) g0(T x) { return x.n; }\n template static decltype(auto) g1(T);\n template static decltype(auto) g2(T);\n };\n\n template class A {\n friend auto f1();\n friend auto f2();\n\n friend decltype(auto) g0<>(A);\n template friend decltype(auto) g1(T);\n template friend decltype(auto) g2(T);\n\n friend auto X::f1();\n friend auto X::f2();\n\n // FIXME (PR38882): 'A' names the class template not the injected-class-name here!\n friend decltype(auto) X::g0<>(A);\n // FIXME (PR38882): ::T hides the template parameter if both are named T here!\n template friend decltype(auto) X::g1(T_);\n template friend decltype(auto) X::g2(T_);\n\n int n;\n };\n\n auto f1() { return A().n; }\n template decltype(auto) g1(T x) { return A().n; }\n\n auto X::f1() { return A().n; }\n template decltype(auto) X::g1(T x) { return A().n; }\n\n A ai;\n int k1 = g0(ai);\n int k2 = X::g0(ai);\n\n int k3 = g1(ai);\n int k4 = X::g1(ai);\n\n auto f2() { return A().n; }\n template decltype(auto) g2(T x) { return A().n; }\n\n auto X::f2() { return A().n; }\n template decltype(auto) X::g2(T x) { return A().n; }\n\n int k5 = g2(ai);\n int k6 = X::g2(ai);\n\n template struct B {\n auto *q() { return (float*)0; } // expected-note 2{{previous}}\n };\n template<> auto *B::q() { return (int*)0; }\n template<> auto B::q() { return (int*)0; } // expected-error {{return type}}\n template<> int B::q() { return 0; } // expected-error {{return type}}\n}\n\nnamespace PR46637 {\n using A = auto () -> auto; // expected-error {{'auto' not allowed in type alias}}\n using B = auto (*)() -> auto; // expected-error {{'auto' not allowed in type alias}}\n template auto> struct X {}; // cxx14-error {{'auto' not allowed in template parameter until C++17}}\n template struct Y { T x; };\n Y auto> y; // expected-error {{'auto' not allowed in template argument}}\n}\n"}},"token":"YJvoGFdkH1lkFl6DCpF3dAzZR5tzYkXj2bGLHKAfM3o=","login":null}