[Clang] Add captures to the instantiation scope of lambda call operators

[cor3ntin]

Summary

Like concepts checking, a trailing return type of a lambda
in a dependent context may refer to captures in which case
they may need to be rebuilt, so the map of local decl
should include captures.

This patch reveal a pre-existing issue.
this is always recomputed by TreeTransform.

*this (like all captures) only become const
after the parameter list.

However, if try to recompute the value of this (in a parameter)
during template instantiation while determining the type of the call operator,
we will determine it to be const (unless the lambda is mutable).

There is no good way to know at that point that we are in a parameter
or not, the easiest/best solution is to transform the type of this.

Note that doing so break a handful of HLSL tests.
So this is a prototype at this point.

Fixes #65067
Fixes #63675

[cor3ntin]

@beanz The changes to TreeTransform.h cause a lot of HLSL test failures similar to this one:

clang: /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/lib/AST/ExprClassification.cpp:57: Cl clang::Expr::ClassifyImpl(clang::ASTContext &, clang::SourceLocation *) const: Assertion `isLValue()' failed.
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: /home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang -cc1 -internal-isystem /home/cor3ntin/dev/compilers/LLVM/build-release/lib/clang/18/include -nostdsysteminc -triple dxil-pc-shadermodel6.0-compute -emit-llvm -o - -O0 /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/test/CodeGenHLSL/builtins/RWBuffer-subscript.hlsl
1.      <eof> parser at end of file
2.      instantiating function definition 'hlsl::RWBuffer<int>::RWBuffer'
 #0 0x00005562645f33c7 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x3d663c7)
 #1 0x00005562645f0f9e llvm::sys::RunSignalHandlers() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x3d63f9e)
 #2 0x00005562645f3bba SignalHandler(int) Signals.cpp:0:0
 #3 0x00007fc625c3c4b0 (/lib/x86_64-linux-gnu/libc.so.6+0x3c4b0)
 #4 0x00007fc625c90ffb __pthread_kill_implementation ./nptl/pthread_kill.c:44:76
 #5 0x00007fc625c90ffb __pthread_kill_internal ./nptl/pthread_kill.c:78:10
 #6 0x00007fc625c90ffb pthread_kill ./nptl/pthread_kill.c:89:10
 #7 0x00007fc625c3c406 raise ./signal/../sysdeps/posix/raise.c:27:6
 #8 0x00007fc625c2287c abort ./stdlib/abort.c:81:7
 #9 0x00007fc625c2279b _nl_load_domain ./intl/loadmsgcat.c:1177:9
#10 0x00007fc625c33b86 (/lib/x86_64-linux-gnu/libc.so.6+0x33b86)
#11 0x0000556267a3f1a9 clang::Expr::ClassifyImpl(clang::ASTContext&, clang::SourceLocation*) const (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x71b21a9)
#12 0x0000556267a3fa37 clang::Expr::isModifiableLvalue(clang::ASTContext&, clang::SourceLocation*) const (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x71b2a37)
#13 0x0000556266ffbd1a CheckForModifiableLvalue(clang::Expr*, clang::SourceLocation, clang::Sema&) SemaExpr.cpp:0:0
#14 0x0000556266ffb4b4 clang::Sema::CheckAssignmentOperands(clang::Expr*, clang::ActionResult<clang::Expr*, true>&, clang::SourceLocation, clang::QualType, clang::BinaryOperatorKind) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x676e4b4)
#15 0x0000556266fddd2e clang::Sema::CreateBuiltinBinOp(clang::SourceLocation, clang::BinaryOperatorKind, clang::Expr*, clang::Expr*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6750d2e)
#16 0x0000556267572779 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformBinaryOperator(clang::BinaryOperator*) SemaTemplateInstantiate.cpp:0:0
#17 0x000055626756ceb5 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformStmt(clang::Stmt*, clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::StmtDiscardKind) SemaTemplateInstantiate.cpp:0:0
#18 0x000055626758c4ba clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformCompoundStmt(clang::CompoundStmt*, bool) SemaTemplateInstantiate.cpp:0:0
#19 0x000055626756ce43 clang::Sema::SubstStmt(clang::Stmt*, clang::MultiLevelTemplateArgumentList const&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6cdfe43)
#20 0x00005562675c6bab clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6d39bab)
#21 0x00005562675c9cbe clang::Sema::PerformPendingInstantiations(bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6d3ccbe)
#22 0x0000556266bf08a5 clang::Sema::ActOnEndOfTranslationUnitFragment(clang::Sema::TUFragmentKind) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x63638a5)
#23 0x0000556266bf1028 clang::Sema::ActOnEndOfTranslationUnit() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6364028)
#24 0x0000556266ab548c clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, clang::Sema::ModuleImportState&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x622848c)
#25 0x0000556266ab007e clang::ParseAST(clang::Sema&, bool, bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x622307e)
#26 0x000055626519ac60 clang::FrontendAction::Execute() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x490dc60)
#27 0x000055626510c96f clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x487f96f)
#28 0x000055626527cc5b clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x49efc5b)
#29 0x000055626341cf64 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b8ff64)
#30 0x0000556263419e3d ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&, llvm::ToolContext const&) driver.cpp:0:0
#31 0x0000556263418b9e clang_main(int, char**, llvm::ToolContext const&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b8bb9e)
#32 0x00005562634298d1 main (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b9c8d1)
#33 0x00007fc625c23a90 __libc_start_call_main ./csu/../sysdeps/nptl/libc_start_call_main.h:74:3
#34 0x00007fc625c23b49 call_init ./csu/../csu/libc-start.c:128:20
#35 0x00007fc625c23b49 __libc_start_main ./csu/../csu/libc-start.c:347:5
#36 0x0000556263416325 _start (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b89325)
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/cor3ntin/dev/compilers/LLVM/build-release/bin/FileCheck /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/test/CodeGenHLSL/builtins/RWBuffer-subscript.hlsl

any idea would be appreciated! Thanks

[aaron.ballman]

In D159126#4625911, @cor3ntin wrote:

@beanz The changes to TreeTransform.h cause a lot of HLSL test failures similar to this one:

clang: /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/lib/AST/ExprClassification.cpp:57: Cl clang::Expr::ClassifyImpl(clang::ASTContext &, clang::SourceLocation *) const: Assertion `isLValue()' failed.
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: /home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang -cc1 -internal-isystem /home/cor3ntin/dev/compilers/LLVM/build-release/lib/clang/18/include -nostdsysteminc -triple dxil-pc-shadermodel6.0-compute -emit-llvm -o - -O0 /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/test/CodeGenHLSL/builtins/RWBuffer-subscript.hlsl
1.      <eof> parser at end of file
2.      instantiating function definition 'hlsl::RWBuffer<int>::RWBuffer'
 #0 0x00005562645f33c7 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x3d663c7)
 #1 0x00005562645f0f9e llvm::sys::RunSignalHandlers() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x3d63f9e)
 #2 0x00005562645f3bba SignalHandler(int) Signals.cpp:0:0
 #3 0x00007fc625c3c4b0 (/lib/x86_64-linux-gnu/libc.so.6+0x3c4b0)
 #4 0x00007fc625c90ffb __pthread_kill_implementation ./nptl/pthread_kill.c:44:76
 #5 0x00007fc625c90ffb __pthread_kill_internal ./nptl/pthread_kill.c:78:10
 #6 0x00007fc625c90ffb pthread_kill ./nptl/pthread_kill.c:89:10
 #7 0x00007fc625c3c406 raise ./signal/../sysdeps/posix/raise.c:27:6
 #8 0x00007fc625c2287c abort ./stdlib/abort.c:81:7
 #9 0x00007fc625c2279b _nl_load_domain ./intl/loadmsgcat.c:1177:9
#10 0x00007fc625c33b86 (/lib/x86_64-linux-gnu/libc.so.6+0x33b86)
#11 0x0000556267a3f1a9 clang::Expr::ClassifyImpl(clang::ASTContext&, clang::SourceLocation*) const (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x71b21a9)
#12 0x0000556267a3fa37 clang::Expr::isModifiableLvalue(clang::ASTContext&, clang::SourceLocation*) const (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x71b2a37)
#13 0x0000556266ffbd1a CheckForModifiableLvalue(clang::Expr*, clang::SourceLocation, clang::Sema&) SemaExpr.cpp:0:0
#14 0x0000556266ffb4b4 clang::Sema::CheckAssignmentOperands(clang::Expr*, clang::ActionResult<clang::Expr*, true>&, clang::SourceLocation, clang::QualType, clang::BinaryOperatorKind) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x676e4b4)
#15 0x0000556266fddd2e clang::Sema::CreateBuiltinBinOp(clang::SourceLocation, clang::BinaryOperatorKind, clang::Expr*, clang::Expr*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6750d2e)
#16 0x0000556267572779 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformBinaryOperator(clang::BinaryOperator*) SemaTemplateInstantiate.cpp:0:0
#17 0x000055626756ceb5 clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformStmt(clang::Stmt*, clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::StmtDiscardKind) SemaTemplateInstantiate.cpp:0:0
#18 0x000055626758c4ba clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformCompoundStmt(clang::CompoundStmt*, bool) SemaTemplateInstantiate.cpp:0:0
#19 0x000055626756ce43 clang::Sema::SubstStmt(clang::Stmt*, clang::MultiLevelTemplateArgumentList const&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6cdfe43)
#20 0x00005562675c6bab clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6d39bab)
#21 0x00005562675c9cbe clang::Sema::PerformPendingInstantiations(bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6d3ccbe)
#22 0x0000556266bf08a5 clang::Sema::ActOnEndOfTranslationUnitFragment(clang::Sema::TUFragmentKind) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x63638a5)
#23 0x0000556266bf1028 clang::Sema::ActOnEndOfTranslationUnit() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x6364028)
#24 0x0000556266ab548c clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, clang::Sema::ModuleImportState&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x622848c)
#25 0x0000556266ab007e clang::ParseAST(clang::Sema&, bool, bool) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x622307e)
#26 0x000055626519ac60 clang::FrontendAction::Execute() (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x490dc60)
#27 0x000055626510c96f clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x487f96f)
#28 0x000055626527cc5b clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x49efc5b)
#29 0x000055626341cf64 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b8ff64)
#30 0x0000556263419e3d ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&, llvm::ToolContext const&) driver.cpp:0:0
#31 0x0000556263418b9e clang_main(int, char**, llvm::ToolContext const&) (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b8bb9e)
#32 0x00005562634298d1 main (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b9c8d1)
#33 0x00007fc625c23a90 __libc_start_call_main ./csu/../sysdeps/nptl/libc_start_call_main.h:74:3
#34 0x00007fc625c23b49 call_init ./csu/../csu/libc-start.c:128:20
#35 0x00007fc625c23b49 __libc_start_main ./csu/../csu/libc-start.c:347:5
#36 0x0000556263416325 _start (/home/cor3ntin/dev/compilers/LLVM/build-release/bin/clang+0x2b89325)
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/cor3ntin/dev/compilers/LLVM/build-release/bin/FileCheck /home/cor3ntin/dev/compilers/LLVM/llvm-project/clang/test/CodeGenHLSL/builtins/RWBuffer-subscript.hlsl

any idea would be appreciated! Thanks

CC @bogner as well

[beanz]

I'll apply this patch and debug the issue today.

[beanz]

@cor3ntin, I know what the problem is and I think I can put up a review for a fix tonight or (more likely) tomorrow. Is that okay?

[cor3ntin]

@beanz Oh wow, excellent, i did not expect a solution so fast! I'm glad to know there may indeed be an issue with HLSL rather than this patch because I'm not sure I could have come up with a different fix!

[beanz]

Yea, the gist of it is that in HLSL this is a reference not a pointer, which means the CXXThisExpr is always an LValue.

I think the right fix for this is to cleanup the CXXThisExpr creation code and create a CXXThisExpr::Create method like the other AST nodes. Then I can have a simpler way to force the CXXThisExpr to always be an LValue for HLSL.

@aaron.ballman, does that sound reasonable?

[cor3ntin]

Rebase

[cor3ntin]

Rebase and cleanups

[cor3ntin]

@erichkeane @aaron.ballman This now pass the tests and is ready for review :)
Thanks to @beanz for the quick turnaround on the HLSL issue

[erichkeane]

1 suggestion, else LGTM.

clang/lib/Sema/SemaLambda.cpp

2263

Wonder if LambdaScopeForCallOperatorInstantiationRAII should just inherit from `FunctionScopeRAII? Am I missing why not?

[cor3ntin]

clang/lib/Sema/SemaLambda.cpp

2263

I suppose it could yes. I think it would have to be protected so that disable is not misused

[erichkeane]

clang/lib/Sema/SemaLambda.cpp

2263

Ah, this isn't the object I thought it was (the actual scope), just the RAII, so I think this is all right/not much benefit to it.

I was afraid it was the actual 'scope' object, so introspection into the list of active scopes would pull us into some private variable/init somewhere rather than the ctor of the containing object. No reason to change this now.

[cor3ntin]

Inherit from FunctionScopeRAII as per @erichkeane

[cor3ntin]

clang/lib/Sema/SemaLambda.cpp

2263

Oups, I missed your reply and changed it. Hopefully you are still happy with it!

[erichkeane]

clang/lib/Sema/SemaLambda.cpp

2263

Yep, no problem with it now, a bit of a brainfart when I suggested it in the first place. Still LGTM.

[abrachet]

I'm seeing libcxx failures after this patch. See https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8770673168839783889/overview

# .---command stderr------------
# | /b/s/w/ir/x/w/llvm-llvm-project/libcxx/test/std/ranges/range.adaptors/range.all/range.owning.view/empty.pass.cpp:38:19: error: static assertion failed due to requirement '!HasEmpty<const std::ranges::owning_view<ComparableIters> &>'
# |    38 |     static_assert(!HasEmpty<const OwningView&>);
# |       |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
# | /b/s/w/ir/x/w/llvm-llvm-project/libcxx/test/std/ranges/range.adaptors/range.all/range.owning.view/empty.pass.cpp:39:19: error: static assertion failed due to requirement '!HasEmpty<const std::ranges::owning_view<ComparableIters> &&>'
# |    39 |     static_assert(!HasEmpty<const OwningView&&>);
# |       |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# | 2 errors generated.
# `-----------------------------

I've verified that reverting this patch fixes those errors. Would you mind taking a look?

[cor3ntin]

@abrachet Thanks, i've reverted the patch while i investigate a fix

I managed to reduced it to

template <class b>
concept cs = requires(b bj) {
  bj.begin();
};
struct {
  template <class b>
  requires cs<b>
  auto operator()(b &&) {}
} begin;
template <class>
concept cu = requires {
  begin;
};
template <class b>
concept cy = requires(b bj) {
  begin(bj);
};
struct {
  template <cy b> void operator()(b &&);
} cz;
template <cu d> class dc {
  d dd;

public:
  void cz() const requires requires { cz(dd); };
};

template <class de>
concept e = requires(de f) {
  f.cz();
};
void g() {
  struct dg {
    void begin();
  };
  using dh = dc<dg>;
  static_assert(!e<dh>);
}

The changes to clang/lib/Sema/TreeTransform.h are what cause the issue

[cor3ntin]

Fix libc++ compile

@erichkeane I struggle to reduce further, do you think it's worth adding this inscrutable
test case somewhere?

[erichkeane]

In D159126#4640484, @cor3ntin wrote:

Fix libc++ compile

@erichkeane I struggle to reduce further, do you think it's worth adding this inscrutable
test case somewhere?

There's definitely value to putting it in somewhere, I'd suggest giving meaningful names to the identifiers however.

[cor3ntin]

Add the test case that caused a build failure

[cor3ntin]

@erichkeane Ok, I added a test!

[thakis]

Looks like the test is missing a RUN line and hence makes lit fail: http://45.33.8.238/linux/117631/step_7.txt

Please take a look and revert for now if it takes a while to fix.

[erichkeane]

In D159126#4642010, @thakis wrote:

Looks like the test is missing a RUN line and hence makes lit fail: http://45.33.8.238/linux/117631/step_7.txt

Please take a look and revert for now if it takes a while to fix.

Won't take a while, it is a pretty simple change, I'll work on it now.

[erichkeane]

In D159126#4642023, @erichkeane wrote:

In D159126#4642010, @thakis wrote:

Looks like the test is missing a RUN line and hence makes lit fail: http://45.33.8.238/linux/117631/step_7.txt

Please take a look and revert for now if it takes a while to fix.

Won't take a while, it is a pretty simple change, I'll work on it now.

Should be fixed in 390b48675be80420f471bd3be74577495b1b1897. We were ALSO missing a 'expected-no-diagnostics' line

[BertalanD]

FYI, we found a crash related to this patch: https://github.com/llvm/llvm-project/issues/67260

clang/docs/ReleaseNotes.rst

 
 - Fix a crash caused by substitution failure in expression requirements.
   (`#64172 <https://github.com/llvm/llvm-project/issues/64172>`_) and
   (`#64723 <https://github.com/llvm/llvm-project/issues/64723>`_).
 
 - Fix crash when parsing the requires clause of some generic lambdas.
   (`#64689 <https://github.com/llvm/llvm-project/issues/64689>`_)
 
+- Fix crash when the trailing return type of a generic and dependent
+  lambda refers to an init-capture.
+  (`#65067 <https://github.com/llvm/llvm-project/issues/65067>`_` and
+   `#63675 <https://github.com/llvm/llvm-project/issues/63675>`_`)
+
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed an import failure of recursive friend class template.
   `Issue 64169 <https://github.com/llvm/llvm-project/issues/64169>`_
 - Remove unnecessary RecordLayout computation when importing UnaryOperator. The
   computed RecordLayout is incorrect if fields are not completely imported and
   should not be cached.
   `Issue 64170 <https://github.com/llvm/llvm-project/issues/64170>`_

clang/include/clang/Sema/Sema.h

 
   ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
                                            SourceLocation ConvLocation,
                                            CXXConversionDecl *Conv,
                                            Expr *Src);
 
   sema::LambdaScopeInfo *RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator);
 
+  class LambdaScopeForCallOperatorInstantiationRAII
+      : private FunctionScopeRAII {
+  public:
+    LambdaScopeForCallOperatorInstantiationRAII(
+        Sema &SemasRef, FunctionDecl *FD, MultiLevelTemplateArgumentList MLTAL,
+        LocalInstantiationScope &Scope);
+  };
+
   /// Check whether the given expression is a valid constraint expression.
   /// A diagnostic is emitted if it is not, false is returned, and
   /// PossibleNonPrimary will be set to true if the failure might be due to a
   /// non-primary expression being used as an atomic constraint.
   bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),
                                  bool *PossibleNonPrimary = nullptr,
                                  bool IsTrailingRequiresClause = false);
 

clang/lib/Sema/SemaConcept.cpp

if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
 
     // If this is a member function, make sure we get the parameters that
     // reference the original primary template.
     if (const auto *FromMemTempl =
             PrimaryTemplate->getInstantiatedFromMemberTemplate()) {
       if (addInstantiatedParametersToScope(FD, FromMemTempl->getTemplatedDecl(),
                                            Scope, MLTAL))
         return true;
-      // Make sure the captures are also added to the instantiation scope.
-      if (isLambdaCallOperator(FD) &&
-          addInstantiatedCapturesToScope(FD, FromMemTempl->getTemplatedDecl(),
-                                         Scope, MLTAL))
-        return true;
     }
 
     return false;
   }
 
   if (FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
       FD->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate) {
     FunctionDecl *InstantiatedFrom =
         FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization
             ? FD->getInstantiatedFromMemberFunction()
             : FD->getInstantiatedFromDecl();
 
     InstantiatingTemplate Inst(
         *this, FD->getPointOfInstantiation(),
         Sema::InstantiatingTemplate::ConstraintsCheck{}, InstantiatedFrom,
         TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
         SourceRange());
     if (Inst.isInvalid())
       return true;
 
     // Case where this was not a template, but instantiated as a
     // child-function.
     if (addInstantiatedParametersToScope(FD, InstantiatedFrom, Scope, MLTAL))
       return true;
-
-    // Make sure the captures are also added to the instantiation scope.
-    if (isLambdaCallOperator(FD) &&
-        addInstantiatedCapturesToScope(FD, InstantiatedFrom, Scope, MLTAL))
-      return true;
   }
 
   return false;
 }
 
 // This function collects all of the template arguments for the purposes of
 // constraint-instantiation and checking.
 std::optional<MultiLevelTemplateArgumentList>
bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = const_cast<CXXRecordDecl *>(Method->getParent());
   }
   CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
 
-  // When checking the constraints of a lambda, we need to restore a
-  // LambdaScopeInfo populated with correct capture information so that the type
-  // of a variable referring to a capture is correctly const-adjusted.
-  FunctionScopeRAII FuncScope(*this);
-  if (isLambdaCallOperator(FD)) {
-    LambdaScopeInfo *LSI = RebuildLambdaScopeInfo(
-        const_cast<CXXMethodDecl *>(cast<CXXMethodDecl>(FD)));
-    // Constraints are checked from the parent context of the lambda, so we set
-    // AfterParameterList to false, so that `tryCaptureVariable` finds
-    // explicit captures in the appropriate context.
-    LSI->AfterParameterList = false;
-  } else {
-    FuncScope.disable();
-  }
+  LambdaScopeForCallOperatorInstantiationRAII LambdaScope(
+      *this, const_cast<FunctionDecl *>(FD), *MLTAL, Scope);
 
   return CheckConstraintSatisfaction(
       FD, {FD->getTrailingRequiresClause()}, *MLTAL,
       SourceRange(UsageLoc.isValid() ? UsageLoc : FD->getLocation()),
       Satisfaction);
 }
 
 
if (!MLTAL)
     return true;
 
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = Method->getParent();
   }
-  CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
-  FunctionScopeRAII FuncScope(*this);
 
-  if (isLambdaCallOperator(Decl)) {
-    LambdaScopeInfo *LSI = RebuildLambdaScopeInfo(cast<CXXMethodDecl>(Decl));
-    LSI->AfterParameterList = false;
-  } else {
-    FuncScope.disable();
-  }
+  CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
+  LambdaScopeForCallOperatorInstantiationRAII LambdaScope(
+      *this, const_cast<FunctionDecl *>(Decl), *MLTAL, Scope);
 
   llvm::SmallVector<Expr *, 1> Converted;
   return CheckConstraintSatisfaction(Template, TemplateAC, Converted, *MLTAL,
                                      PointOfInstantiation, Satisfaction);
 }
 
 static void diagnoseUnsatisfiedRequirement(Sema &S,
                                            concepts::ExprRequirement *Req,

clang/lib/Sema/SemaDecl.cpp

 
 LambdaScopeInfo *Sema::RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator) {
   CXXRecordDecl *LambdaClass = CallOperator->getParent();
 
   LambdaScopeInfo *LSI = PushLambdaScope();
   LSI->CallOperator = CallOperator;
   LSI->Lambda = LambdaClass;
   LSI->ReturnType = CallOperator->getReturnType();
+  // This function in calls in situation where the context of the call operator
+  // is not entered, so we set AfterParameterList to false, so that
+  // `tryCaptureVariable` finds explicit captures in the appropriate context.
+  LSI->AfterParameterList = false;
   const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
 
   if (LCD == LCD_None)
     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
   else if (LCD == LCD_ByCopy)
     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
   else if (LCD == LCD_ByRef)
     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;

clang/lib/Sema/SemaLambda.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaLambda.h"
+#include "clang/Sema/Template.h"
 #include "llvm/ADT/STLExtras.h"
 #include <optional>
 using namespace clang;
 using namespace sema;
 
 /// Examines the FunctionScopeInfo stack to determine the nearest
 /// enclosing lambda (to the current lambda) that is 'capture-ready' for
 /// the variable referenced in the current lambda (i.e. \p VarToCapture).
ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
 
   // Create the block literal expression.
   Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType());
   ExprCleanupObjects.push_back(Block);
   Cleanup.setExprNeedsCleanups(true);
 
   return BuildBlock;
 }
+
+Sema::LambdaScopeForCallOperatorInstantiationRAII::
+    LambdaScopeForCallOperatorInstantiationRAII(
+        Sema &SemasRef, FunctionDecl *FD, MultiLevelTemplateArgumentList MLTAL,
+        LocalInstantiationScope &Scope)
+    : FunctionScopeRAII(SemasRef) {
+  if (!isLambdaCallOperator(FD)) {
+    FunctionScopeRAII::disable();
+    return;
+  }
+
+  if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
+    FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate();
+    if (const auto *FromMemTempl =
+            PrimaryTemplate->getInstantiatedFromMemberTemplate()) {
+      SemasRef.addInstantiatedCapturesToScope(
+          FD, FromMemTempl->getTemplatedDecl(), Scope, MLTAL);
+    }
+  }
+
+  else if (FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
+           FD->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate) {
+    FunctionDecl *InstantiatedFrom =
+        FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization
+            ? FD->getInstantiatedFromMemberFunction()
+            : FD->getInstantiatedFromDecl();
+    SemasRef.addInstantiatedCapturesToScope(FD, InstantiatedFrom, Scope, MLTAL);
+  }
+
+  SemasRef.RebuildLambdaScopeInfo(cast<CXXMethodDecl>(FD));
+}

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
   else
     isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
 
   bool MergeWithParentScope = (TemplateParams != nullptr) ||
     !(isa<Decl>(Owner) &&
       cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
   LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
 
+  Sema::LambdaScopeForCallOperatorInstantiationRAII LambdaScope(
+      SemaRef, const_cast<CXXMethodDecl *>(D), TemplateArgs, Scope);
+
   // Instantiate enclosing template arguments for friends.
   SmallVector<TemplateParameterList *, 4> TempParamLists;
   unsigned NumTempParamLists = 0;
   if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
     TempParamLists.resize(NumTempParamLists);
     for (unsigned I = 0; I != NumTempParamLists; ++I) {
       TemplateParameterList *TempParams = D->getTemplateParameterList(I);
       TemplateParameterList *InstParams = SubstTemplateParams(TempParams);

clang/lib/Sema/TreeTransform.h

 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
                                                      CXXNullPtrLiteralExpr *E) {
   return E;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
-  QualType T = getSema().getCurrentThisType();
+
+  // In lambdas, the qualifiers of the type depends of where in
+  // the call operator `this` appear, and we do not have a good way to
+  // rebuild this information, so we transform the type.
+  //
+  // In other contexts, the type of `this` may be overrided
+  // for type deduction, so we need to recompute it.
+  QualType T = getSema().getCurLambda() ?
+                   getDerived().TransformType(E->getType())
+                 : getSema().getCurrentThisType();
 
   if (!getDerived().AlwaysRebuild() && T == E->getType()) {
     // Mark it referenced in the new context regardless.
     // FIXME: this is a bit instantiation-specific.
     getSema().MarkThisReferenced(E);
     return E;
   }
 

clang/test/SemaCXX/lambda-capture-type-deduction.cpp

void f(int) {
   int i;
   [i]<C P>(P) {}(0);
   i = 4;
 }
 
 void test() { f<int>(0);  }
 
 }
+
+namespace GH65067 {
+
+template <typename> class a {
+public:
+  template <typename b> void c(b f) { d<int>(f)(0); }
+  template <typename, typename b> auto d(b f) {
+    return [f = f](auto arg) -> a<decltype(f(arg))> { return {}; };
+  }
+};
+a<void> e;
+auto fn1() {
+  e.c([](int) {});
+}
+
+}
+
+namespace GH63675 {
+
+template <class _Tp> _Tp __declval();
+struct __get_tag {
+  template <class _Tag> void operator()(_Tag);
+};
+template <class _ImplFn> struct __basic_sender {
+  using __tag_t = decltype(__declval<_ImplFn>()(__declval<__get_tag>()));
+  _ImplFn __impl_;
+};
+auto __make_basic_sender = []<class... _Children>(
+                               _Children... __children) {
+  return __basic_sender{[... __children = __children]<class _Fun>(
+                     _Fun __fun) -> decltype(__fun(__children...)) {}};
+};
+void __trans_tmp_1() {
+  __make_basic_sender(__trans_tmp_1);
+}
+
+}

clang/test/SemaCXX/this-type-deduction-concept.cpp

+
+// This test case came up in the review of
+// https://reviews.llvm.org/D159126
+// when transforming `this` within a
+// requires expression, we need to make sure
+// the type of this (and its qualifiers) is respected.
+namespace D159126 {
+
+template <class _Tp>
+concept __member_begin = requires(_Tp __t) {
+  __t.begin();
+};
+
+struct {
+  template <class _Tp>
+  requires __member_begin<_Tp>
+  auto operator()(_Tp &&) {}
+} inline begin;
+
+template <class>
+concept range = requires {
+  begin;
+};
+
+template <class _Tp>
+concept __can_compare_begin = requires(_Tp __t) {
+  begin(__t);
+};
+
+struct {
+  template <__can_compare_begin _Tp> void operator()(_Tp &&);
+} empty;
+
+template <range _Rp> struct owning_view {
+  _Rp __r_;
+public:
+  void empty() const requires requires { empty(__r_); };
+};
+
+template <class T>
+concept HasEmpty = requires(T t) {
+  t.empty();
+};
+
+struct ComparableIters {
+    void begin();
+};
+
+static_assert(HasEmpty<owning_view<ComparableIters&>>);
+static_assert(HasEmpty<owning_view<ComparableIters&&>>);
+static_assert(!HasEmpty<owning_view<const ComparableIters&>>);
+static_assert(!HasEmpty<owning_view<const ComparableIters&&>>);
+
+}