[clang] Add a note "deducing return type for 'foo'"

[• Quuxplusone]

Summary

Emit the note when we fail to deduce a return type, or deduce conflicting return types.

[ChuanqiXu]

I am curious about the behavior if we removed the guard if (OrigResultType.getBeginLoc().isValid()).

clang/lib/Sema/SemaStmt.cpp

3804–3807

What if merge this one into above block where the diagnostic happens.

[• Quuxplusone]

Rebase; adjust more expected output in tests.

[• Quuxplusone]

clang/lib/Sema/SemaStmt.cpp

3805

I am curious about the behavior if we removed the guard if (OrigResultType.getBeginLoc().isValid()).

That caused the note to be emitted in some cases without a source location (similar to https://github.com/llvm/llvm-project/issues/29054 ). I admit I should check to make sure we have a test case for each of these four ifs, though; I suspect we don't.

$ cat x.cpp
auto f = []() { return x; };

$ clang++ x.cpp
x.cpp:1:24: error: use of undeclared identifier 'x'
auto f = []() { return x; };
                       ^
note: deducing return type for 'operator()'
1 error generated.

[rsmith]

clang/lib/Sema/SemaStmt.cpp

3804–3809

The approach of tacking a note onto the end of someone else's diagnostic is an antipattern and should be avoided in new code. For example, if DeduceAutoType produces an error (which is shown) then a warning (which is hidden), the note will be attached to the warning, and will not appear.

The right thing to do is to create a new kind of CodeSynthesisContext for this case and push that. Then we'll use the same logic as in template instantiation backtraces, and the note will get properly attached to the first emitted diagnostic within the context. This will also remove the need to track down all the different places that emit diagnostics (like we see below): you just push the context when you start doing the action you want to attach the note to and pop it when you're done. It'll also properly order the note with respect to other context notes.

[• Quuxplusone]

I'll update with the CodeSynthesisContext approach in a little bit. But meanwhile there's a problem with both the current patch and (I think even more) with the new approach. @rsmith any help?:
When I try my latest patch with the libc++ tests, with bin/llvm-lit -sv --param enable_modules=True (which corresponds to the -fmodules compiler flag), I get lots of errors like the following. Do you have any idea what's going wrong?

I can't minimize the example beyond "all of libc++" because Modules prevents creduce from doing anything meaningful. And unfortunately whatever's going wrong seems to be specifically about Modules.

Assertion failed: (Replacement.isCanonical() && "replacement types must always be canonical"), function getSubstTemplateTypeParmType, file /Users/aodwyer/llvm-project/clang/lib/AST/ASTContext.cpp, line 4691.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /Users/aodwyer/llvm-project/build3/bin/clang-14 -cc1 -triple x86_64-apple-macosx10.15.0 -Wundef-prefix=TARGET_OS_ -Werror=undef-prefix -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -emit-obj -mrelax-all --mrelax-relocations -disable-free -clear-ast-before-backend -main-file-name rbegin.pass.cpp -mrelocation-model pic -pic-level 2 -mframe-pointer=all -ffp-contract=on -fno-rounding-math -funwind-tables=2 -target-sdk-version=10.15.6 -fcompatibility-qualified-id-block-type-checking -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -mllvm -treat-scalable-fixed-error-as-warning -debugger-tuning=lldb -target-linker-version 609.8 -v -fcoverage-compilation-dir=/Users/aodwyer/llvm-project/build3/projects/libcxx/test/std/ranges/range.access -nostdinc++ -resource-dir /Users/aodwyer/llvm-project/build3/lib/clang/15.0.0 -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk -isystem /Users/aodwyer/llvm-project/build3/include/c++/v1 -I /Users/aodwyer/llvm-project/build3/projects/libcxx/include/c++build -I /Users/aodwyer/llvm-project/libcxx/test/support -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -stdlib=libc++ -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/usr/local/include -internal-isystem /Users/aodwyer/llvm-project/build3/lib/clang/15.0.0/include -internal-externc-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/usr/include -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -std=c++20 -fdeprecated-macro -fdebug-compilation-dir=/Users/aodwyer/llvm-project/build3/projects/libcxx/test/std/ranges/range.access -ferror-limit 19 -stack-protector 1 -fblocks -fencode-extended-block-signature -fcoroutines-ts -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fmodules -fimplicit-module-maps -fmodules-cache-path=/var/folders/0l/9t0yv2890_g4wgmy53n_mg7w0000gy/C/clang/ModuleCache -fmodules-validate-system-headers -fcxx-exceptions -fexceptions -fmax-type-align=16 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/folders/0l/9t0yv2890_g4wgmy53n_mg7w0000gy/T/lit-tmp-fkh9o_f4/rbegin-d58043.o -x c++ /Users/aodwyer/llvm-project/libcxx/test/std/ranges/range.access/rbegin.pass.cpp
1.	/Users/aodwyer/llvm-project/libcxx/test/support/test_iterators.h:524:30: current parser token '{'
Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it):
0  clang-14                 0x000000010634385d llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 61
1  clang-14                 0x0000000106343ddb PrintStackTraceSignalHandler(void*) + 27
2  clang-14                 0x0000000106341cfa llvm::sys::RunSignalHandlers() + 138
3  clang-14                 0x00000001063457af SignalHandler(int) + 223
4  libsystem_platform.dylib 0x00007fff677255fd _sigtramp + 29
5  libsystem_platform.dylib 0x00007ffeed912f58 _sigtramp + 18446744071664753016
6  libsystem_c.dylib        0x00007fff675fb808 abort + 120
7  libsystem_c.dylib        0x00007fff675faac6 err + 0
8  clang-14                 0x000000010b769ce1 clang::ASTContext::getSubstTemplateTypeParmType(clang::TemplateTypeParmType const*, clang::QualType) const + 161
9  clang-14                 0x000000010b1feb40 (anonymous namespace)::TemplateInstantiator::TransformTemplateTypeParmType(clang::TypeLocBuilder&, clang::TemplateTypeParmTypeLoc) + 1456
10 clang-14                 0x000000010b1ba74f clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeLocBuilder&, clang::TypeLoc) + 4383
11 clang-14                 0x000000010b1b91e2 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeSourceInfo*) + 354
12 clang-14                 0x000000010b1e9137 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateArgument(clang::TemplateArgumentLoc const&, clang::TemplateArgumentLoc&, bool) + 1079
13 clang-14                 0x000000010b1e8c4f bool clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateArguments<clang::TemplateArgumentLocInventIterator<(anonymous namespace)::TemplateInstantiator, clang::TemplateArgument const*> >(clang::TemplateArgumentLocInventIterator<(anonymous namespace)::TemplateInstantiator, clang::TemplateArgument const*>, clang::TemplateArgumentLocInventIterator<(anonymous namespace)::TemplateInstantiator, clang::TemplateArgument const*>, clang::TemplateArgumentListInfo&, bool) + 2447
14 clang-14                 0x000000010b1e7981 bool clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateArguments<clang::TemplateArgumentLocContainerIterator<clang::TemplateSpecializationTypeLoc> >(clang::TemplateArgumentLocContainerIterator<clang::TemplateSpecializationTypeLoc>, clang::TemplateArgumentLocContainerIterator<clang::TemplateSpecializationTypeLoc>, clang::TemplateArgumentListInfo&, bool) + 289
15 clang-14                 0x000000010b1e6e3e clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateSpecializationType(clang::TypeLocBuilder&, clang::TemplateSpecializationTypeLoc, clang::TemplateName) + 286
16 clang-14                 0x000000010b1e6a7b clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTSIInObjectScope(clang::TypeLoc, clang::QualType, clang::NamedDecl*, clang::CXXScopeSpec&) + 523
17 clang-14                 0x000000010b21c0c5 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTypeInObjectScope(clang::TypeLoc, clang::QualType, clang::NamedDecl*, clang::CXXScopeSpec&) + 165
18 clang-14                 0x000000010b1c88a5 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc, clang::QualType, clang::NamedDecl*) + 1365
19 clang-14                 0x000000010b1f5f55 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformDependentNameType(clang::TypeLocBuilder&, clang::DependentNameTypeLoc, bool) + 149
20 clang-14                 0x000000010b1fa140 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformDependentNameType(clang::TypeLocBuilder&, clang::DependentNameTypeLoc) + 64
21 clang-14                 0x000000010b1b9d4a clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeLocBuilder&, clang::TypeLoc) + 1818
22 clang-14                 0x000000010b1b91e2 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeSourceInfo*) + 354
23 clang-14                 0x000000010b1bad21 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::QualType) + 161
24 clang-14                 0x000000010b1fdf9f clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformSubstTemplateTypeParmType(clang::TypeLocBuilder&, clang::SubstTemplateTypeParmTypeLoc) + 143
25 clang-14                 0x000000010b1ba5d3 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeLocBuilder&, clang::TypeLoc) + 4003
26 clang-14                 0x000000010b1b91e2 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformType(clang::TypeSourceInfo*) + 354
27 clang-14                 0x000000010b1e9137 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateArgument(clang::TemplateArgumentLoc const&, clang::TemplateArgumentLoc&, bool) + 1079
28 clang-14                 0x000000010b1c543c bool clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformTemplateArguments<clang::TemplateArgumentLoc const*>(clang::TemplateArgumentLoc const*, clang::TemplateArgumentLoc const*, clang::TemplateArgumentListInfo&, bool) + 2428
29 clang-14                 0x000000010b1bc136 clang::Sema::SubstTemplateArguments(llvm::ArrayRef<clang::TemplateArgumentLoc>, clang::MultiLevelTemplateArgumentList const&, clang::TemplateArgumentListInfo&) + 182
30 clang-14                 0x000000010a4d15f6 substituteParameterMappings(clang::Sema&, clang::NormalizedConstraint&, clang::ConceptDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::ASTTemplateArgumentListInfo const*) + 1574
31 clang-14                 0x000000010a4d1088 substituteParameterMappings(clang::Sema&, clang::NormalizedConstraint&, clang::ConceptDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::ASTTemplateArgumentListInfo const*) + 184
32 clang-14                 0x000000010a4d1088 substituteParameterMappings(clang::Sema&, clang::NormalizedConstraint&, clang::ConceptDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::ASTTemplateArgumentListInfo const*) + 184
33 clang-14                 0x000000010a4d1088 substituteParameterMappings(clang::Sema&, clang::NormalizedConstraint&, clang::ConceptDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::ASTTemplateArgumentListInfo const*) + 184
34 clang-14                 0x000000010a4d0cf7 clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 1079
35 clang-14                 0x000000010a4d0a05 clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 325
36 clang-14                 0x000000010a4d099e clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 222
37 clang-14                 0x000000010a4d099e clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 222
38 clang-14                 0x000000010a4d03e4 clang::NormalizedConstraint::fromConstraintExprs(clang::Sema&, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 164
39 clang-14                 0x000000010a4cffa7 clang::Sema::getNormalizedAssociatedConstraints(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 151
40 clang-14                 0x000000010a4d0bec clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 812
41 clang-14                 0x000000010a4d03e4 clang::NormalizedConstraint::fromConstraintExprs(clang::Sema&, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 164
42 clang-14                 0x000000010a4cffa7 clang::Sema::getNormalizedAssociatedConstraints(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 151
43 clang-14                 0x000000010a4d0bec clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 812
44 clang-14                 0x000000010a4d0a05 clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 325
45 clang-14                 0x000000010a4d099e clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 222
46 clang-14                 0x000000010a4d099e clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 222
47 clang-14                 0x000000010a4d03e4 clang::NormalizedConstraint::fromConstraintExprs(clang::Sema&, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 164
48 clang-14                 0x000000010a4cffa7 clang::Sema::getNormalizedAssociatedConstraints(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 151
49 clang-14                 0x000000010a4d0bec clang::NormalizedConstraint::fromConstraintExpr(clang::Sema&, clang::NamedDecl*, clang::Expr const*) + 812
50 clang-14                 0x000000010a4d03e4 clang::NormalizedConstraint::fromConstraintExprs(clang::Sema&, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 164
51 clang-14                 0x000000010a4cffa7 clang::Sema::getNormalizedAssociatedConstraints(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) + 151
52 clang-14                 0x000000010a4d1d96 bool subsumes<clang::Sema::IsAtLeastAsConstrained(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, bool&)::$_2>(clang::Sema&, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, bool&, clang::Sema::IsAtLeastAsConstrained(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, bool&)::$_2) + 150
53 clang-14                 0x000000010a4d1a2b clang::Sema::IsAtLeastAsConstrained(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, bool&) + 411
54 clang-14                 0x000000010b0cfe2c clang::Sema::isMoreSpecializedThanPrimary(clang::ClassTemplatePartialSpecializationDecl*, clang::sema::TemplateDeductionInfo&) + 428
55 clang-14                 0x000000010b0758dd void checkMoreSpecializedThanPrimary<clang::ClassTemplatePartialSpecializationDecl>(clang::Sema&, clang::ClassTemplatePartialSpecializationDecl*) + 141
56 clang-14                 0x000000010af84a20 void checkTemplatePartialSpecialization<clang::ClassTemplatePartialSpecializationDecl>(clang::Sema&, clang::ClassTemplatePartialSpecializationDecl*) + 32
57 clang-14                 0x000000010af849ed clang::Sema::CheckTemplatePartialSpecialization(clang::ClassTemplatePartialSpecializationDecl*) + 29
58 clang-14                 0x000000010af932db clang::Sema::ActOnClassTemplateSpecialization(clang::Scope*, unsigned int, clang::Sema::TagUseKind, clang::SourceLocation, clang::SourceLocation, clang::CXXScopeSpec&, clang::TemplateIdAnnotation&, clang::ParsedAttributesView const&, llvm::MutableArrayRef<clang::TemplateParameterList*>, clang::Sema::SkipBodyInfo*) + 5195
59 clang-14                 0x0000000109f81f63 clang::Parser::ParseClassSpecifier(clang::tok::TokenKind, clang::SourceLocation, clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, bool, clang::Parser::DeclSpecContext, clang::ParsedAttributesWithRange&) + 7187
60 clang-14                 0x0000000109f60058 clang::Parser::ParseDeclarationSpecifiers(clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, clang::Parser::DeclSpecContext, clang::Parser::LateParsedAttrList*) + 17192
61 clang-14                 0x000000010a0336e9 clang::Parser::ParseSingleDeclarationAfterTemplate(clang::DeclaratorContext, clang::Parser::ParsedTemplateInfo const&, clang::ParsingDeclRAIIObject&, clang::SourceLocation&, clang::ParsedAttributes&, clang::AccessSpecifier) + 841
62 clang-14                 0x000000010a032a22 clang::Parser::ParseTemplateDeclarationOrSpecialization(clang::DeclaratorContext, clang::SourceLocation&, clang::ParsedAttributes&, clang::AccessSpecifier) + 1426
63 clang-14                 0x000000010a032354 clang::Parser::ParseDeclarationStartingWithTemplate(clang::DeclaratorContext, clang::SourceLocation&, clang::ParsedAttributes&, clang::AccessSpecifier) + 228

[rsmith]

In D119778#3326285, @Quuxplusone wrote:

I'll update with the CodeSynthesisContext approach in a little bit. But meanwhile there's a problem with both the current patch and (I think even more) with the new approach. @rsmith any help?:
When I try my latest patch with the libc++ tests, with bin/llvm-lit -sv --param enable_modules=True (which corresponds to the -fmodules compiler flag), I get lots of errors like the following. Do you have any idea what's going wrong?

I don't see any obvious way that this patch could be responsible for that failure, unless it's something like a pre-existing use of uninitialized memory or a use-after-free and this patch is just changing the happenstance behavior.

I can't minimize the example beyond "all of libc++" because Modules prevents creduce from doing anything meaningful. And unfortunately whatever's going wrong seems to be specifically about Modules.

It'd likely be useful to know what the Replacement type is, if you can observe this crash in a debugger. I think it's possible for a type that was canonical prior to serialization and deserialization to be non-canonical afterwards (perhaps because we picked a different declaration of the type to be the first one or merged types in a different order or something like that). It may be that we just need to map to a canonical type in some suitable place.

[• Quuxplusone]

Apply @rsmith's suggested approach.

I don't see any obvious way that this patch could be responsible for that failure, unless it's something like a pre-existing use of uninitialized memory or a use-after-free and this patch is just changing the happenstance behavior.

Well, it might more likely be the fault of D119184 rather than this one per se. D119184 is doing things with Context.VoidTy that weren't there before; could any of that new code be the culprit?

[rsmith]

In D119778#3327161, @Quuxplusone wrote:

Apply @rsmith's suggested approach.

Thanks, the structure of the change looks good to me.

Looking through the test changes, I'm a bit torn by the value proposition of this note. Some of the errors were already pointing at the return type itself, and others were pointing at the return statement. I can see value in making sure that we mention both when diagnosing return type deduction errors, but pointing out the return type twice and never mentioning the return statement seems a bit noisy. I don't think I have any great suggestions here, though; there's not really a great way we can determine which of the two a diagnostic is pointing at so we can point the note at the other one.

The cases that I found in the tests that seem particularly bad today:

template<typename T> concept Never = false;
void g();
// error: cannot form a reference to 'void'
auto &f() {
    // ...
    return g();
}
// error: deduced type 'void' does not satisfy 'Never'
Never auto h() {
    // ...
    return g();
}

... would both benefit from a note saying "return type deduced from returned expression of type 'void' here" or something like that, and aren't really helped much by this change. But I think noting *both* the return statement and the return type would be too much (then we guarantee we always have at least one noisy note). :(

What do you think? This seems on balance to be near the edge between a useful note and a noisy note, though in many of the specific cases it's pretty clearly on one side or the other.

I don't see any obvious way that this patch could be responsible for that failure, unless it's something like a pre-existing use of uninitialized memory or a use-after-free and this patch is just changing the happenstance behavior.

Well, it might more likely be the fault of D119184 rather than this one per se. D119184 is doing things with Context.VoidTy that weren't there before; could any of that new code be the culprit?

That seems more likely, but nothing in that patch is jumping out at me. Especially given that it only affects the behavior of return type deduction in a function with either no return statements or only return;, it's pretty weird that libc++ would even exercise the patch.

clang/test/SemaCXX/deduced-return-void.cpp

153–155

This seems like an unfortunate case: both the error and the note point at the return type and neither points at the return statement.

clang/test/SemaTemplate/concepts.cpp

176–178

This is an unfortunate case: the existing error message already points at the C auto constraint, so we now have an error and a note both pointing at the return type, and nothing pointing to the return statement itself.

[• Quuxplusone]

Rebased after landing D119184. I'm no longer necessarily trying to land this note (it's not directly relevant to my interests anymore), but I'd like to show its CI as green before I abandon it. @rsmith would you like me to do something other than abandon this?

clang/include/clang/Basic/DiagnosticSemaKinds.td

   "cannot deduce return type %0 from omitted return expression">;
 def err_auto_fn_return_init_list : Error<
   "cannot deduce return type from initializer list">;
 def err_auto_fn_virtual : Error<
   "function with deduced return type cannot be virtual">;
 def warn_cxx11_compat_deduced_return_type : Warning<
   "return type deduction is incompatible with C++ standards before C++14">,
   InGroup<CXXPre14Compat>, DefaultIgnore;
+def note_deducing_return_type_for : Note<
+  "deducing return type for %0">;
 
 // C++11 override control
 def override_keyword_only_allowed_on_virtual_member_functions : Error<
   "only virtual member functions can be marked '%0'">;
 def override_keyword_hides_virtual_member_function : Error<
   "non-virtual member function marked '%0' hides virtual member "
   "%select{function|functions}1">;
 def err_function_marked_override_not_overriding : Error<

clang/include/clang/Sema/Sema.h

 
       /// We are marking a class as __dllexport.
       MarkingClassDllexported,
 
       /// Added for Template instantiation observation.
       /// Memoization means we are _not_ instantiating a template because
       /// it is already instantiated (but we entered a context where we
       /// would have had to if it was not already instantiated).
-      Memoization
+      Memoization,
+
+      /// We are deducing a function return type from its return statement.
+      ReturnTypeDeduction,
     } Kind;
 
     /// Was the enclosing context a non-instantiation SFINAE context?
     bool SavedInNonInstantiationSFINAEContext;
 
     /// The point of instantiation or synthesis within the source code.
     SourceLocation PointOfInstantiation;
 

clang/lib/Frontend/FrontendActions.cpp

static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
     case CodeSynthesisContext::RequirementInstantiation:
       return "RequirementInstantiation";
     case CodeSynthesisContext::NestedRequirementConstraintsCheck:
       return "NestedRequirementConstraintsCheck";
     case CodeSynthesisContext::InitializingStructuredBinding:
       return "InitializingStructuredBinding";
     case CodeSynthesisContext::MarkingClassDllexported:
       return "MarkingClassDllexported";
+    case CodeSynthesisContext::ReturnTypeDeduction:
+      return "ReturnTypeDeduction";
     }
     return "";
   }
 
   template <bool BeginInstantiation>
   static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
                                     const CodeSynthesisContext &Inst) {
     std::string YAML;

clang/lib/Sema/SemaStmt.cpp

 
 TypeLoc Sema::getReturnTypeLoc(FunctionDecl *FD) const {
   return FD->getTypeSourceInfo()
       ->getTypeLoc()
       .getAsAdjusted<FunctionProtoTypeLoc>()
       .getReturnLoc();
 }
 
+namespace {
+struct DeducingReturnType {
+  Sema &S;
+  explicit DeducingReturnType(Sema& S, TypeLoc OrigResultType, FunctionDecl *FD)
+      : S(S) {
+    Sema::CodeSynthesisContext Ctx;
+    Ctx.Kind = Sema::CodeSynthesisContext::ReturnTypeDeduction;
+    Ctx.PointOfInstantiation = OrigResultType.getBeginLoc();
+    Ctx.Entity = FD;
+    Ctx.InstantiationRange = OrigResultType.getSourceRange();
+    S.pushCodeSynthesisContext(Ctx);
+  }
+  ~DeducingReturnType() {
+    S.popCodeSynthesisContext();
+  }
+};
+} // namespace
+
 /// Deduce the return type for a function from a returned expression, per
 /// C++1y [dcl.spec.auto]p6.
 bool Sema::DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
                                             SourceLocation ReturnLoc,
                                             Expr *&RetExpr,
                                             const AutoType *AT) {
   // If this is the conversion function for a lambda, we choose to deduce its
   // type from the corresponding call operator, not from the synthesized return
   // statement within it. See Sema::DeduceReturnType.
   if (isLambdaConversionOperator(FD))
     return false;
 
   TypeLoc OrigResultType = getReturnTypeLoc(FD);
+  DeducingReturnType DRT(*this, OrigResultType, FD);
   QualType Deduced;
 
   if (RetExpr && isa<InitListExpr>(RetExpr)) {
     //  If the deduction is for a return statement and the initializer is
     //  a braced-init-list, the program is ill-formed.
     Diag(RetExpr->getExprLoc(),
          getCurLambda() ? diag::err_lambda_return_init_list
                         : diag::err_auto_fn_return_init_list)
         << RetExpr->getSourceRange();
     return true;
   }
 
   if (FD->isDependentContext()) {
     // C++1y [dcl.spec.auto]p12:
     //   Return type deduction [...] occurs when the definition is
     //   instantiated even if the function body contains a return
     //   statement with a non-type-dependent operand.
     assert(AT->isDeduced() && "should have deduced to dependent type");
     return false;
   }
 
   if (RetExpr) {
     //  Otherwise, [...] deduce a value for U using the rules of template
     //  argument deduction.
     DeduceAutoResult DAR = DeduceAutoType(OrigResultType, RetExpr, Deduced);
 

clang/lib/Sema/SemaTemplateInstantiate.cpp

bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   case DefiningSynthesizedFunction:
   case ExceptionSpecEvaluation:
   case ConstraintSubstitution:
   case ParameterMappingSubstitution:
   case ConstraintNormalization:
   case RewritingOperatorAsSpaceship:
   case InitializingStructuredBinding:
   case MarkingClassDllexported:
+  case ReturnTypeDeduction:
     return false;
 
   // This function should never be called when Kind's value is Memoization.
   case Memoization:
     break;
   }
 
   llvm_unreachable("Invalid SynthesisKind!");
case CodeSynthesisContext::MarkingClassDllexported:
       Diags.Report(Active->PointOfInstantiation,
                    diag::note_due_to_dllexported_class)
           << cast<CXXRecordDecl>(Active->Entity) << !getLangOpts().CPlusPlus11;
       break;
 
     case CodeSynthesisContext::Memoization:
       break;
 
+    case CodeSynthesisContext::ReturnTypeDeduction:
+      // PointOfInstantiation and InstantiationRange both point at the AutoType
+      // in the function declaration. If this is a lambda with an implied 'auto',
+      // there is no source location for that AutoType, so we shouldn't emit
+      // the note.
+      if (Active->PointOfInstantiation.isValid())
+        Diags.Report(Active->PointOfInstantiation,
+                     diag::note_deducing_return_type_for)
+            << cast<FunctionDecl>(Active->Entity) << Active->InstantiationRange;
+      break;
+
     case CodeSynthesisContext::ConstraintsCheck: {
       unsigned DiagID = 0;
       if (!Active->Entity) {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_nested_requirement_here)
           << Active->InstantiationRange;
         break;
       }
case CodeSynthesisContext::TemplateInstantiation:
         break;
       LLVM_FALLTHROUGH;
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
     case CodeSynthesisContext::ExceptionSpecInstantiation:
     case CodeSynthesisContext::ConstraintsCheck:
     case CodeSynthesisContext::ParameterMappingSubstitution:
     case CodeSynthesisContext::ConstraintNormalization:
     case CodeSynthesisContext::NestedRequirementConstraintsCheck:
+    case CodeSynthesisContext::ReturnTypeDeduction:
       // This is a template instantiation, so there is no SFINAE.
       return None;
 
     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
     case CodeSynthesisContext::RewritingOperatorAsSpaceship:
       // A default template argument instantiation and substitution into

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p2-1z.cpp

auto c() {
   if constexpr (true)
     return "foo";
   else
     return 'x';
   if constexpr (false)
     return 7.6;
   else
     return 5; // expected-error {{deduced as 'int' here but deduced as 'const char *' in earlier}}
+              // expected-note@-9 {{deducing return type for 'c'}}
 }
 
 template<int k> auto d() {
   if constexpr(k == 0)
     return 0;
   if constexpr(k == 1)
     return "foo";
   else if constexpr (k == 2)

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

 auto f5ad(int n) { decltype(auto) x = f(); return x; }
 decltype(auto) f5da(int n) { auto x = f(); return x; }
 decltype(auto) f5dd(int n) { decltype(auto) x = f(); return x; } // cxx14_20-error {{rvalue reference to type 'int' cannot bind to lvalue}}
 using Int = decltype(f5aa(0));
 using Int = decltype(f5ad(0));
 using Int = decltype(f5da(0));
 
 auto init_list_1() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}
+                                           // expected-note@-1 {{deducing return type for 'init_list_1'}}
 decltype(auto) init_list_2() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}
+                                                     // expected-note@-1 {{deducing return type for 'init_list_2'}}

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

 namespace X {
   template<typename T, unsigned size>
   concept SmallerThan = sizeof(T) < size;
   template<typename T>
   concept Small = SmallerThan<T, 2>;
 }
 
 Large auto test1() { // expected-error{{deduced type 'char' does not satisfy 'Large'}}
+                     // expected-note@-1{{deducing return type for 'test1'}}
   Large auto i = 'a';
   // expected-error@-1{{deduced type 'char' does not satisfy 'Large'}}
   Large auto j = 10;
   ::Large auto k = 10;
   LargerThan<1> auto l = 10;
   ::LargerThan<1> auto m = 10;
   LargerThan<10> auto n = 10;
   // expected-error@-1{{deduced type 'int' does not satisfy 'LargerThan<10>'}}
   X::Small auto o = 'x';
   X::SmallerThan<5> auto p = 1;
   return 'a';
 }
 
 ::Large auto test2() { return 10; }
 LargerThan<4> auto test3() { return 10; }
 // expected-error@-1{{deduced type 'int' does not satisfy 'LargerThan<4>'}}
+// expected-note@-2{{deducing return type for 'test3'}}
 ::LargerThan<2> auto test4() { return 10; }
 
 Large auto test5() -> void;
 // expected-error@-1{{function with trailing return type must specify return type 'auto', not 'Large auto'}}
 auto test6() -> Large auto { return 1; }
 
 X::Small auto test7() { return 'a'; }
 X::SmallerThan<5> auto test8() { return 10; }

clang/test/SemaCUDA/autoret-global.cu

 }
 
 __global__ auto f1() {
 }
 
 __global__ auto f2(int x) {
   return x + 1;
   // expected-error@-2 {{kernel function type 'auto (int)' must have void return type}}
+  // expected-note@-3 {{deducing return type for 'f2'}}
 }
 
 template <bool Cond, typename T = void> struct enable_if { typedef T type; };
 template <typename T> struct enable_if<false, T> {};
 
 template <int N>
 __global__
 auto bar() -> typename enable_if<N == 1>::type {

clang/test/SemaCXX/cxx2b-consteval-if.cpp

 // RUN: %clang_cc1 -std=c++2b -verify %s
 
 namespace PR52206 {
 constexpr auto f() {
   if consteval  { return 0;   }
   if !consteval { return 0.0; } // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}}
+                                // expected-note@-3 {{deducing return type for 'f'}}
 }
 
 constexpr auto g() {
   if !consteval { return 0;   }
   if consteval  { return 0.0; } // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}}
+                                // expected-note@-3 {{deducing return type for 'g'}}
 }
 
 constexpr auto h() {
   if consteval  { return 0; }
   if !consteval { return 0; } // okay
 }
 
 constexpr auto i() {
   if consteval {
     if consteval { // expected-warning {{consteval if is always true in an immediate context}}
       return 1;
     }
     return 2;
   } else {
     return 1.0; // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}}
+                // expected-note@-8 {{deducing return type for 'i'}}
   }
 }
 
 void test() {
   auto x1 = f();
   constexpr auto y1 = f();
 
   auto x2 = g();

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

auto c() {
   BothOps().operator auto(); // ok
   BothOps().operator auto *(); // ok
   JustTemplateOp().operator auto(); // expected-error {{no member named 'operator auto' in 'JustTemplateOp'}}
   JustTemplateOp().operator auto *(); // expected-error {{no member named 'operator auto *' in 'JustTemplateOp'}}
 }
 
 auto *ptr_1() {
   return 100; // expected-error {{cannot deduce return type 'auto *' from returned value of type 'int'}}
+              // expected-note@-2 {{deducing return type for 'ptr_1'}}
 }
 
 const auto &ref_1() {
   return 0; // expected-warning {{returning reference to local temporary}}
 }
 
 auto init_list() {
   return { 1, 2, 3 }; // expected-error {{cannot deduce return type from initializer list}}
+                      // expected-note@-2 {{deducing return type for 'init_list'}}
 }
 
 auto fwd_decl(); // expected-note 2{{here}}
 
 int n = fwd_decl(); // expected-error {{function 'fwd_decl' with deduced return type cannot be used before it is defined}}
 int k = sizeof(fwd_decl()); // expected-error {{used before it is defined}}
 
 auto fac(int n) {

 const auto void_ret_3() {} // ok, return type 'const void' is adjusted to 'void'
 
 const auto void_ret_4() {
   if (false)
     return void();
   if (false)
     return;
   return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}
+            // expected-note@-6 {{deducing return type for 'void_ret_4'}}
 }
 
 namespace Templates {
   template<typename T> auto f1() {
     return T() + 1;
   }
   template<typename T> auto &f2(T &&v) { return v; }
   // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}

clang/test/SemaCXX/deduced-return-void.cpp

 namespace JustAuto {
 int i;
 auto f1() { }
 auto f2() { return; }
 auto f3() { return void(); }
 auto f4() {
   return i;
   return; // expected-error {{'auto' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+          // expected-note@-3 {{deducing return type for 'f4'}}
 }
 auto f5() {
   return i;
   return void(); // expected-error {{'auto' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+                 // expected-note@-3 {{deducing return type for 'f5'}}
 }
 
 auto l1 = []() { };
 auto l2 = []() { return; };
 auto l3 = []() { return void(); };
 auto l4 = []() {
   return i;
   return; // expected-error {{return type 'void' must match previous return type 'int' when lambda expression has unspecified explicit return type}}
 };
 auto l5 = []() {
   return i;
   return void(); // expected-error {{return type 'void' must match previous return type 'int' when lambda expression has unspecified explicit return type}}
 };
 
 } // namespace JustAuto
 
 namespace DecltypeAuto {
 int i;
 decltype(auto) f1() { }
 decltype(auto) f2() { return; }
 decltype(auto) f3() { return void(); }
 decltype(auto) f4() {
   return i;
   return; // expected-error {{'decltype(auto)' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+          // expected-note@-3 {{deducing return type for 'f4'}}
 }
 decltype(auto) f5() {
   return i;
   return void(); // expected-error {{'decltype(auto)' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+                 // expected-note@-3 {{deducing return type for 'f5'}}
 }
 
 auto l1 = []() -> decltype(auto) { };
 auto l2 = []() -> decltype(auto) { return; };
 auto l3 = []() -> decltype(auto) { return void(); };
 auto l4 = []() -> decltype(auto) {
   return i;
   return; // expected-error {{'decltype(auto)' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+          // expected-note@-3 {{deducing return type for 'operator()'}}
 };
 auto l5 = []() -> decltype(auto) {
   return i;
   return void(); // expected-error {{'decltype(auto)' in return type deduced as 'void' here but deduced as 'int' in earlier return statement}}
+                 // expected-note@-3 {{deducing return type for 'operator()'}}
 };
 
 } // namespace DecltypeAuto
 
 namespace AutoPtr {
 int i;
 auto *f1() { } // expected-error {{cannot deduce return type 'auto *' for function with no return statements}}
 auto *f2() {
   return; // expected-error {{cannot deduce return type 'auto *' from omitted return expression}}
+          // expected-note@-2 {{deducing return type for 'f2'}}
 }
 auto *f3() {
   return void(); // expected-error {{cannot deduce return type 'auto *' from returned value of type 'void'}}
+                 // expected-note@-2 {{deducing return type for 'f3'}}
 }
 auto *f4() {
   return &i;
   return; // expected-error {{cannot deduce return type 'auto *' from omitted return expression}}
+          // expected-note@-3 {{deducing return type for 'f4'}}
 }
 auto *f5() {
   return &i;
   return void(); // expected-error {{cannot deduce return type 'auto *' from returned value of type 'void'}}
+                 // expected-note@-3 {{deducing return type for 'f5'}}
 }
 
 auto l1 = []() -> auto* { }; // expected-error {{cannot deduce return type 'auto *' for function with no return statements}}
 auto l2 = []() -> auto* {
   return; // expected-error {{cannot deduce return type 'auto *' from omitted return expression}}
+          // expected-note@-2 {{deducing return type for 'operator()'}}
 };
 auto l3 = []() -> auto* {
   return void(); // expected-error {{cannot deduce return type 'auto *' from returned value of type 'void'}}
+                 // expected-note@-2 {{deducing return type for 'operator()'}}
 };
 auto l4 = []() -> auto* {
   return &i;
   return; // expected-error {{cannot deduce return type 'auto *' from omitted return expression}}
+          // expected-note@-3 {{deducing return type for 'operator()'}}
 };
 auto l5 = []() -> auto* {
   return &i;
   return void(); // expected-error {{cannot deduce return type 'auto *' from returned value of type 'void'}}
+                 // expected-note@-3 {{deducing return type for 'operator()'}}
 };
 } // namespace AutoPtr
 
 namespace AutoRef {
 int i;
 auto& f1() { // expected-error {{cannot deduce return type 'auto &' for function with no return statements}}
 }
 auto& f2() {
   return; // expected-error {{cannot deduce return type 'auto &' from omitted return expression}}
+          // expected-note@-2 {{deducing return type for 'f2'}}
 }
 auto& f3() {
   return void(); // expected-error@-1 {{cannot form a reference to 'void'}}
+                 // expected-note@-2 {{deducing return type for 'f3'}}
 }
 auto& f4() {
   return i;
   return; // expected-error {{cannot deduce return type 'auto &' from omitted return expression}}
+          // expected-note@-3 {{deducing return type for 'f4'}}
 }
 auto& f5() {
   return i;
   return void(); // expected-error@-2 {{cannot form a reference to 'void'}}
+                 // expected-note@-3 {{deducing return type for 'f5'}}
 }
 auto& f6() { return 42; } // expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 
 auto l1 = []() -> auto& { }; // expected-error {{cannot deduce return type 'auto &' for function with no return statements}}
 auto l2 = []() -> auto& {
   return; // expected-error {{cannot deduce return type 'auto &' from omitted return expression}}
+          // expected-note@-2 {{deducing return type for 'operator()'}}
 };
 auto l3 = []() -> auto& { // expected-error {{cannot form a reference to 'void'}}
+                          // expected-note@-1 {{deducing return type for 'operator()'}}
   return void();
 };
-auto l4 = []() -> auto& {
+auto l4 = []() -> auto& { // expected-note {{deducing return type for 'operator()'}}
   return i;
   return; // expected-error {{cannot deduce return type 'auto &' from omitted return expression}}
 };
 auto l5 = []() -> auto& { // expected-error {{cannot form a reference to 'void'}}
+                          // expected-note@-1 {{deducing return type for 'operator()'}}
   return i;
   return void();
 };
 auto l6 = []() -> auto& {
   return 42; // expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 };
 } // namespace AutoRef

clang/test/SemaCXX/typo-correction-crash.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
 auto check1() {
   return 1;
   return s; // expected-error {{use of undeclared identifier 's'}}
 }
 
 int test = 11; // expected-note 2 {{'test' declared here}}
 auto check2() {
   return "s";
   return tes; // expected-error {{use of undeclared identifier 'tes'; did you mean 'test'?}}
               // expected-error@-1 {{deduced as 'int' here but deduced as 'const char *' in earlier}}
+              // expected-note@-4 {{deducing return type for 'check2'}}
 }
 
 template <class A, class B> struct is_same { static constexpr bool value = false; };
 template <class A> struct is_same<A,A> { static constexpr bool value = true; };
 
 auto L1 = [] { return s; }; // expected-error {{use of undeclared identifier 's'}}
 using T1 = decltype(L1());
 // FIXME: Suppress the 'undeclared identifier T1' diagnostic, the UsingDecl T1 is discarded because of an invalid L1().

clang/test/SemaTemplate/concepts.cpp

void g3() {
      ...); // expected-error {{does not contain any unexpanded}}
   }
 
   template<typename ...T> void g4() {
     []() -> C<T> auto{ return T(); }(); // expected-error {{expression contains unexpanded parameter pack 'T'}}
   }
   template<typename ...T> void g5() {
     ([]() -> C<T> auto{ // expected-error-re {{deduced type {{.*}} does not satisfy}}
+                        // expected-note@-1 {{deducing return type for 'operator()'}}
      return T();
      }(), ...);
   }
   template void g5<int, int, int>(); // OK
   template void g5<int, char, double>(); // expected-note {{in instantiation of}}
   void g6() {
     ([]<typename ...T>() -> C<T> auto{ // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
      return T(); // expected-error {{expression contains unexpanded parameter pack 'T'}}
namespace PR50561 {
   template<typename> concept C = false;
   template<typename T, typename U> void f(T, U);
   template<C T, typename U> void f(T, U) = delete;
   void g() { f(0, 0); }
 }
 
 namespace PR49188 {
   template<class T> concept C = false;     // expected-note 6 {{because 'false' evaluated to false}}
 
   C auto f1() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                // expected-note@-1 {{deducing return type for 'f1'}}
     return void();
   }
   C auto f2() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                // expected-note@-1 {{deducing return type for 'f2'}}
     return;
   }
   C auto f3() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                // expected-note@-1 {{deducing return type for 'f3'}}
   }
   C decltype(auto) f4() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                          // expected-note@-1 {{deducing return type for 'f4'}}
     return void();
   }
   C decltype(auto) f5() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                          // expected-note@-1 {{deducing return type for 'f5'}}
     return;
   }
   C decltype(auto) f6() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                          // expected-note@-1 {{deducing return type for 'f6'}}
   }
   C auto& f7() { // expected-error {{cannot form a reference to 'void'}}
+                 // expected-note@-1 {{deducing return type for 'f7'}}
     return void();
   }
   C auto& f8() {
     return; // expected-error {{cannot deduce return type 'C auto &' from omitted return expression}}
+            // expected-note@-2 {{deducing return type for 'f8'}}
   }
   C auto& f9() { // expected-error {{cannot deduce return type 'C auto &' for function with no return statements}}
   }
 }
 namespace PR53911 {
   template<class T> concept C = false;
 
   C auto *f1() {
     return (void*)nullptr; // FIXME: should error
   }
   C auto *f2() {
     return (int*)nullptr; // FIXME: should error
   }
 }