[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

177–180

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/lib/Sema/SemaStmt.cpp

     //  Otherwise, [...] deduce a value for U using the rules of template
     //  argument deduction.
     DeduceAutoResult DAR = DeduceAutoType(OrigResultType, RetExpr, Deduced);
 
     if (DAR == DAR_Failed && !FD->isInvalidDecl())
       Diag(RetExpr->getExprLoc(), diag::err_auto_fn_deduction_failure)
         << OrigResultType.getType() << RetExpr->getType();
 
-    if (DAR != DAR_Succeeded)
+    if (DAR != DAR_Succeeded) {
+      if (OrigResultType.getBeginLoc().isValid())
+        Diag(OrigResultType.getBeginLoc(), diag::note_deducing_return_type_for)
+            << FD << OrigResultType.getSourceRange();
       return true;
+    }
 
     // If a local type is part of the returned type, mark its fields as
     // referenced.
     LocalTypedefNameReferencer Referencer(*this);
     Referencer.TraverseType(RetExpr->getType());
   } else {
     // For a function with a deduced result type to return void,
     // the result type as written must be 'auto' or 'decltype(auto)',
     // possibly cv-qualified or constrained, but not ref-qualified.
     if (!FD->getReturnType()->getAs<AutoType>()) {
       Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)
           << OrigResultType.getType();
+      if (OrigResultType.getBeginLoc().isValid())
+        Diag(OrigResultType.getBeginLoc(), diag::note_deducing_return_type_for)
+            << FD << OrigResultType.getSourceRange();
       return true;
     }
     // In the case of a return with no operand, the initializer is considered
     // to be 'void()'.
     Expr *Dummy = new (Context) CXXScalarValueInitExpr(
         Context.VoidTy,
         Context.getTrivialTypeSourceInfo(Context.VoidTy, ReturnLoc), ReturnLoc);
     DeduceAutoResult DAR = DeduceAutoType(OrigResultType, Dummy, Deduced);
 
     if (DAR == DAR_Failed && !FD->isInvalidDecl())
       Diag(ReturnLoc, diag::err_auto_fn_deduction_failure)
         << OrigResultType.getType() << Dummy->getType();
 
-    if (DAR != DAR_Succeeded)
+    if (DAR != DAR_Succeeded) {
+      if (OrigResultType.getBeginLoc().isValid())
+        Diag(OrigResultType.getBeginLoc(), diag::note_deducing_return_type_for)
+            << FD << OrigResultType.getSourceRange();
       return true;
+    }
   }
 
   // CUDA: Kernel function must have 'void' return type.
   if (getLangOpts().CUDA)
     if (FD->hasAttr<CUDAGlobalAttr>() && !Deduced->isVoidType()) {
       Diag(FD->getLocation(), diag::err_kern_type_not_void_return)
           << FD->getType() << FD->getSourceRange();
       return true;

       if (LambdaSI && LambdaSI->HasImplicitReturnType) {
         Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)
           << NewAT->getDeducedType() << DeducedT
           << true /*IsLambda*/;
       } else {
         Diag(ReturnLoc, diag::err_auto_fn_different_deductions)
           << (AT->isDecltypeAuto() ? 1 : 0)
           << NewAT->getDeducedType() << DeducedT;
+        if (OrigResultType.getBeginLoc().isValid())
+          Diag(OrigResultType.getBeginLoc(), diag::note_deducing_return_type_for)
+            << FD << OrigResultType.getSourceRange();
       }
       return true;
     }
   } else if (!FD->isInvalidDecl()) {
     // Update all declarations of the function to have the deduced return type.
     Context.adjustDeducedFunctionResultType(FD, Deduced);
   }
 

clang/test/Sema/invalid-bitwidth-expr.mm

 // RUN: %clang_cc1 -fobjc-runtime=gcc -frecovery-ast -verify %s
 
 @interface Ivar
 {
   int Foo : foo(); // expected-error {{use of undeclared identifier}}
 };
 @end
 
 struct X { int Y: foo(); }; // expected-error {{use of undeclared identifier}}
 
 constexpr int s = sizeof(Ivar);
 constexpr int ss = sizeof(X);
 
 auto func() {
   return undef(); // expected-error {{use of undeclared identifier}}
+                  // expected-note@-2 {{deducing return type for 'func'}}
 }
 struct Y {
   int X : func();
 };
 constexpr int sss = sizeof(Y);
 
 bool Foo(int *); // expected-note {{candidate function not viable}}
 template <typename T>
 struct Base {};
 template <typename T>
-auto func() {
+auto func() { // expected-note {{deducing return type for 'func<int>'}}
   // error-bit should be propagated from TemplateArgument to NestNameSpecifier.
   class Base<decltype(Foo(T()))>::type C; // expected-error {{no matching function for call to 'Foo'}}
   return C;
 }
 struct Z {
   int X : func<int>(); // expected-note {{in instantiation of function template}}
 };
 constexpr int ssss = sizeof(Z);
 
 struct Z2 {
   int X : sizeof(_BitInt(invalid())); // expected-error {{use of undeclared identifier}}
 };
 constexpr int sssss = sizeof(Z2);

clang/test/SemaCXX/cxx20-p0388-unbound-ary.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s
 // RUN: %clang_cc1 -std=c++17 -verify %s
 
 // p0388 conversions to unbounded array
 // dcl.init.list/3
 
 namespace One {
 int ga[1];
 
 auto &frob1() {
   int(&r1)[] = ga;
 #if __cplusplus < 202002
   // expected-error@-2{{cannot bind to a value of unrelated type}}
+  // expected-note@-4{{deducing return type for 'frob1'}}
 #endif
 
   return r1;
 }
 
 auto &frob2(int (&arp)[1]) {
   int(&r2)[] = arp;
 #if __cplusplus < 202002
   // expected-error@-2{{cannot bind to a value of unrelated type}}
+  // expected-note@-4{{deducing return type for 'frob2'}}
 #endif
 
   return r2;
 }
 } // namespace One
 
 namespace Two {
 int ga[1];

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;
+      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}}
 }
 
 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) {
   if (n <= 2)
     return n;
   return n * fac(n-1); // ok
 }
 
 auto fac_2(int n) { // expected-note {{declared here}}
   if (n > 2)
     return n * fac_2(n-1); // expected-error {{cannot be used before it is defined}}
+                           // expected-note@-3 {{deducing return type for 'fac_2'}}
   return n;
 }
 
 auto void_ret() {}
 using Void = void;
 using Void = decltype(void_ret());
 
 auto &void_ret_2() {} // expected-error {{cannot deduce return type 'auto &' for function with no return statements}}
 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/std-compare-cxx2a.cpp

 inline namespace __1 {
 struct partial_ordering; // expected-note {{forward declaration}}
 }
 } // namespace std
 
 auto compare_incomplete_test() {
   // expected-error@+1 {{incomplete type 'std::partial_ordering' where a complete type is required}}
   return (-1.2 <=> 123.0);
+  // expected-note@-3 {{deducing return type for 'compare_incomplete_test'}}
 }
 
 namespace std {
 inline namespace __1 {
 struct partial_ordering {
   unsigned value;
 };
 } // namespace __1
 } // namespace std
 
 auto missing_member_test() {
   // expected-error@+1 {{standard library implementation of 'std::partial_ordering' is not supported; member 'equivalent' is missing}}
   return (1.0 <=> 1.0);
+  // expected-note@-3 {{deducing return type for 'missing_member_test'}}
 }
 
 namespace std {
 inline namespace __1 {
 struct strong_ordering {
   long long value;
   static const strong_ordering equal; // expected-note {{declared here}}
 };
 } // namespace __1
 } // namespace std
 
 auto test_non_constexpr_var() {
   // expected-error@+1 {{standard library implementation of 'std::strong_ordering' is not supported; member 'equal' does not have expected form}}
   return (1 <=> 0);
+  // expected-note@-3 {{deducing return type for 'test_non_constexpr_var'}}
 }
 
 #else
 
 namespace std {
 inline namespace __1 {
 struct strong_ordering {
   char value = 0;
   constexpr strong_ordering() = default;
   // non-trivial
   constexpr strong_ordering(strong_ordering const &other) : value(other.value) {}
 };
 } // namespace __1
 } // namespace std
 
 auto test_non_trivial(int LHS, int RHS) {
   // expected-error@+1 {{standard library implementation of 'std::strong_ordering' is not supported; the type is not trivially copyable}}
   return LHS <=> RHS;
+  // expected-note@-3 {{deducing return type for 'test_non_trivial'}}
 }
 
 #endif

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'}}
+            // expected-note@-3 {{deducing return type for 'check1'}}
 }
 
 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/SemaOpenCLCXX/template-astype.cl

 // RUN: %clang_cc1 -fdeclare-opencl-builtins -finclude-default-header %s -cl-std=clc++ -verify
 
 // Test as_type, which is defined in terms of __builtin_astype.
 template <typename T>
 auto templated_astype(T x) {
   return as_int2(x);
   // expected-error@-1{{invalid reinterpretation: sizes of 'int2' (vector of 2 'int' values) and '__private int' must match}}
 }
 
 auto test_long(long x) { return templated_astype(x); }
 
 auto neg_test_int(int x) { return templated_astype(x); }
 // expected-note@-1{{in instantiation of function template specialization 'templated_astype<int>' requested here}}
+// expected-note@-2{{deducing return type for 'neg_test_int'}}
 
 auto test_short4(short4 x) { return templated_astype(x); }
 
 // Test __builtin_astype.
 template <typename T>
 auto templated_builtin_astype(T x) {
   return __builtin_astype(x, int2);
 }
 
 auto test_builtin(char8 x) { return templated_builtin_astype(x); }

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 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() { return void(); }           // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f1'}}
   C auto f2() { return; }                  // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f2'}}
   C auto f3() {}                           // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f3'}}
   C decltype(auto) f4() { return void(); } // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f4'}}
   C decltype(auto) f5() { return; }        // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f5'}}
   C decltype(auto) f6() {}                 // expected-error {{deduced type 'void' does not satisfy 'C'}}
+                                           // expected-note@-1 {{deducing return type for 'f6'}}
 
   void g() {
     f1();
     f2();
     f3();
     f4();
     f5();
     f6();
   }
 }