[Clang] Implement Change scope of lambda trailing-return-type

[cor3ntin]

Summary

This implements P2036R3 and P2579R0.
That is, explicit, int, and implicit capture become visible
at the start of the parameter head.

[cor3ntin]

Hey folks.
I do not intend this to be merge but if there is anyway this can be battle tested against internal codebases, i think it could be helpful to help guide how WG21 proceed with this feature.
Here is a paper listing the failures encountered when we merged the previous attempt, and offers a more holistic mitigation - by looking a head for the mutable keyword https://isocpp.org/files/papers/D2579R0.pdf

Sorry again for the troubles the previous attempt caused but I'm glad we caught this problem sooner rather than later...

[cor3ntin]

note to self.
@aaron.ballman noticed this patch doesn't handle leading attributes correctly

constexpr int asp = 5;
[=] [[gnu::regparm(asp)]] () {};

[cor3ntin]

Now that Kona is over, I'm hoping to get back to that in the coming weeks. Rebasing will be... fun.
I want to make sure we are all okay making that a DR following WG21 guidance, given that not making it a DR would have potentially large impact on the PR.
Thanks!

[aaron.ballman]

In D124351#3940786, @cor3ntin wrote:

Now that Kona is over, I'm hoping to get back to that in the coming weeks. Rebasing will be... fun.
I want to make sure we are all okay making that a DR following WG21 guidance, given that not making it a DR would have potentially large impact on the PR.
Thanks!

To me, it depends on how much existing code the DR breaks in practice. If we don't expect it to break a significant body of code (or if the code that breaks will be materially improved as a result of the required changes), then we should implement it as a DR as far back as we can go. If it breaks too much code in practice, then we might not want to implement it as a DR in older language modes. If that situation comes up and it's very hard for us to carry both implementations, then we should go back to WG21 with the further information before the DIS ballot goes out (if possible).

I'm adding clang-vendors to the review group because of the potential for disruption.

[cor3ntin]

In D124351#3940888, @aaron.ballman wrote:

In D124351#3940786, @cor3ntin wrote:

Now that Kona is over, I'm hoping to get back to that in the coming weeks. Rebasing will be... fun.
I want to make sure we are all okay making that a DR following WG21 guidance, given that not making it a DR would have potentially large impact on the PR.
Thanks!

To me, it depends on how much existing code the DR breaks in practice. If we don't expect it to break a significant body of code (or if the code that breaks will be materially improved as a result of the required changes), then we should implement it as a DR as far back as we can go.

We expect very little, if any, breakage

If it breaks too much code in practice, then we might not want to implement it as a DR in older language modes. If that situation comes up and it's very hard for us to carry both implementations, then we should go back to WG21 with the further information before the DIS ballot goes out (if possible).

Agreed, but time is short

I'm adding clang-vendors to the review group because of the potential for disruption.

[aaron.ballman]

In D124351#3940890, @cor3ntin wrote:

In D124351#3940888, @aaron.ballman wrote:

In D124351#3940786, @cor3ntin wrote:

Now that Kona is over, I'm hoping to get back to that in the coming weeks. Rebasing will be... fun.
I want to make sure we are all okay making that a DR following WG21 guidance, given that not making it a DR would have potentially large impact on the PR.
Thanks!

To me, it depends on how much existing code the DR breaks in practice. If we don't expect it to break a significant body of code (or if the code that breaks will be materially improved as a result of the required changes), then we should implement it as a DR as far back as we can go.

We expect very little, if any, breakage

Then I think we should approach it as a DR and we can react if we get further feedback.

[cor3ntin]

Rebase. This is still a bit rough, I have a few tests to fix
and some dead code to remove.

---

@erichkeane I wouldn't mind picking your brain on this.
Consider:

template <typename T>
void dependent_init_capture(T x = 0) {
  [y = x] () requires (decltype(y){1}) {
    return y;
  }();
}

void test_dependent() {
  dependent_init_capture(0);
}

This used to ""work"" in the previous iteration of the patch,
but with the late concept checking it seems more involved.

My understanding so far is that in CheckFunctionConstraints
we can't find an instanciated declaration of y (so it asserts in LocalInstantiationScope::findInstantiationOf).

I'm not 100% sure of what's the correct approach here would be.
My guess is that we might need to retransform the captures in the instanciation scope used
for constraint checking?
I'm not actually sure whether an instanciation of the lambda does exist at that point in some other scope,
though. Ideally we would not instannciate lambdas more times than needed.

Another issue is that there is no way to walk back from a call expression to a lambda expression,
so we might need to add that.

[cor3ntin]

@erichkeane Let me know if you have any insights on that constraint checking issue.
I might add a way to get from the CXXRecordDecl to the LambdaExpr and add the captures to the instantiation scope during constraint checking that way, but I'd love your opinion before going that direction. Thanks!

[erichkeane]

In D124351#3950805, @cor3ntin wrote:

Rebase. This is still a bit rough, I have a few tests to fix
and some dead code to remove.

---

@erichkeane I wouldn't mind picking your brain on this.
Consider:

template <typename T>
void dependent_init_capture(T x = 0) {
  [y = x] () requires (decltype(y){1}) {
    return y;
  }();
}

void test_dependent() {
  dependent_init_capture(0);
}

This used to ""work"" in the previous iteration of the patch,
but with the late concept checking it seems more involved.

My understanding so far is that in CheckFunctionConstraints
we can't find an instanciated declaration of y (so it asserts in LocalInstantiationScope::findInstantiationOf).

I'm not 100% sure of what's the correct approach here would be.
My guess is that we might need to retransform the captures in the instanciation scope used
for constraint checking?
I'm not actually sure whether an instanciation of the lambda does exist at that point in some other scope,
though. Ideally we would not instannciate lambdas more times than needed.

Another issue is that there is no way to walk back from a call expression to a lambda expression,
so we might need to add that.

We shouldnn't -re-transform' the capture, but we need to make sure we get it into the current scope. I haven't looked at lambda instantiation much, so I don't know where that 'y' usually ends up? Can you do a run of it when it WORKS and see where it finds that when calling FindInstantiatedDecl. I'm guessing we are currently counting on that coming from a PARENT of the CurrentInstantiationScope (one of the Outers), which we can no longer count on.

FindInstantiatedDecl needs some unfortunate amount of work around lambdas, I found similar issues when working on https://reviews.llvm.org/D138148 which I need to get back to when I re-start work next year.

[eandrews]

I came across a strange error when capturing arguments in a lambda inside another lambda. I filed an issue here - https://github.com/llvm/llvm-project/issues/59549

Short reproducer:

void foo () {
  constexpr int i = 2;

  [&]() {
    [=]() [[clang::annotate_type("test", i)]]{};
  };
}

<source>:5:42: error: variable 'i' cannot be implicitly captured in a lambda with no capture-default specified
    [=]() [[clang::annotate_type("test", i)]]{};
                                         ^
<source>:2:17: note: 'i' declared here
  constexpr int i = 2;

I noticed the error is not thrown if 'i' is captured in lambda body instead. IIUC all changes pertaining to P2036R3 has been reverted from clang right? So this bug is an existing issue in Clang with how attributes on lambdas are handled? Will this case be fixed in this PR?

[cor3ntin]

In D124351#4001050, @eandrews wrote:

I came across a strange error when capturing arguments in a lambda inside another lambda. I filed an issue here - https://github.com/llvm/llvm-project/issues/59549

Short reproducer:

void foo () {
  constexpr int i = 2;

  [&]() {
    [=]() [[clang::annotate_type("test", i)]]{};
  };
}

<source>:5:42: error: variable 'i' cannot be implicitly captured in a lambda with no capture-default specified
    [=]() [[clang::annotate_type("test", i)]]{};
                                         ^
<source>:2:17: note: 'i' declared here
  constexpr int i = 2;

I noticed the error is not thrown if 'i' is captured in lambda body instead. IIUC all changes pertaining to P2036R3 has been reverted from clang right? So this bug is an existing issue in Clang with how attributes on lambdas are handled? Will this case be fixed in this PR?

Yes, this does fix that, thanks for reporting.
Prior to this change, i would be looked for in the parent scope which explains why capturing it in the inner lambda solves the issue.

[cor3ntin]

Fix fix-it tests

[cor3ntin]

Handle late constraints checking and fully implement P2579.

[cor3ntin]

Update release notes and commit message

[cor3ntin]

Remove unused variables

[cor3ntin]

revert WS only change, removed unused DelayedCapture type

[cor3ntin]

Remove the lookahead parsing code code which is no longer necessary

[aaron.ballman]

clang/include/clang/AST/DeclCXX.h

1802–1814

Minor simplification

clang/include/clang/Sema/Scope.h

144

clang/include/clang/Sema/ScopeInfo.h

868–870

Re-flow comment (I might have gotten that wrong) and add a full stop at the end of the comment.

clang/include/clang/Sema/Sema.h

6876–6880

You can re-flow this comment to 80 col as well.

6999

clang/lib/Parse/ParseExprCXX.cpp

1316

Typically, we call an ActOn method after having parsed the construct; in this case, we're calling ActOnLambdaIntroducer() when it was parsed elsewhere (this is the parsing code for after the introducer). So perhaps this should be moved elsewhere or renamed?

1389

This isn't being used?

1395–1401

The comment doesn't seem to match the code -- this isn't parsing into the late parsed attribute list?

1542–1544

1548–1550

clang/lib/Sema/SemaConcept.cpp

503–505 ↗

(On Diff #483820)

508–509 ↗

(On Diff #483820)

584–588 ↗

(On Diff #483820)

615–618 ↗

(On Diff #483820)

clang/lib/Sema/SemaLambda.cpp

441–444

975–976

975–976

976–977

983

986

1007

Spell out the type

1291–1370

1333

1343

clang/lib/Sema/TreeTransform.h

13142–13143

[cor3ntin]

• Address Aaron's comments (except renaming ActOnLambdaIntroducer as we pounder on it)
• Delete an aditional outdated comment

[cor3ntin]

clang/lib/Parse/ParseExprCXX.cpp

1316

ActOnLambdaExpressionAfterIntroducer?
We are actually acting on the lambda introducer, but it needs to be done in these scopes so it's why its there.

1389

It used to be! Thanks for catching that

1395–1401

More dead code!

[aaron.ballman]

clang/lib/Parse/ParseExprCXX.cpp

1316

Yeah, that's about the best name I can come up with as well. It's a bit messy because there's not really a clear separation of the steps of building up a lambda, but I think it's defensible.

[aaron.ballman]

Aside from these minor nits and the naming concerns, I think this LGTM.

clang/docs/ReleaseNotes.rst

286–292

This change looks like it needs to be made on the Clang 16 branch as it was a drive-by change here.

288–291

This will probably need rebasing.

[cor3ntin]

• rebase
• rename ActOnLambdaIntroducer
• Fix a crash in transformedLocalDecl

[cor3ntin]

@aaron.ballman Thanks for the review! I hope we won't find further issue with the paper this time :)

[nikic]

FYI this causes a minor compile-time regression (around 0.35% on 7zip at O0): http://llvm-compile-time-tracker.com/compare.php?from=cd173cbd7cca69c29df42cd4b42e60433435c29b&to=d708a186b6a9b050d09558163dd353d9f738c82d&stat=instructions%3Au

Just wanted to check whether that's expected.

[cor3ntin]

In D124351#4093840, @nikic wrote:

FYI this causes a minor compile-time regression (around 0.35% on 7zip at O0): http://llvm-compile-time-tracker.com/compare.php?from=cd173cbd7cca69c29df42cd4b42e60433435c29b&to=d708a186b6a9b050d09558163dd353d9f738c82d&stat=instructions%3Au

Just wanted to check whether that's expected.

It's certainly not great but not entirely unexpected as we are doing quite a bit more work, although it should only affect code that constructs a lot of distinct lambda. Maybe an issue to track that would be useful, there may be some improvements opportunities
Thanks a lot for letting me know

[dblaikie]

In D124351#4097110, @cor3ntin wrote:

In D124351#4093840, @nikic wrote:

FYI this causes a minor compile-time regression (around 0.35% on 7zip at O0): http://llvm-compile-time-tracker.com/compare.php?from=cd173cbd7cca69c29df42cd4b42e60433435c29b&to=d708a186b6a9b050d09558163dd353d9f738c82d&stat=instructions%3Au

Just wanted to check whether that's expected.

It's certainly not great but not entirely unexpected as we are doing quite a bit more work, although it should only affect code that constructs a lot of distinct lambda.

Does 7zip meet that criteria? As a gut-check that this only costs in that case, would be nice to know if the 7zip regression is that case, or is this the cost even when that isn't true - so we could expect higher costs when it is true?

[aaron.ballman]

In D124351#4097192, @dblaikie wrote:

In D124351#4097110, @cor3ntin wrote:

In D124351#4093840, @nikic wrote:

FYI this causes a minor compile-time regression (around 0.35% on 7zip at O0): http://llvm-compile-time-tracker.com/compare.php?from=cd173cbd7cca69c29df42cd4b42e60433435c29b&to=d708a186b6a9b050d09558163dd353d9f738c82d&stat=instructions%3Au

Just wanted to check whether that's expected.

It's certainly not great but not entirely unexpected as we are doing quite a bit more work, although it should only affect code that constructs a lot of distinct lambda.

Does 7zip meet that criteria? As a gut-check that this only costs in that case, would be nice to know if the 7zip regression is that case, or is this the cost even when that isn't true - so we could expect higher costs when it is true?

I just downloaded their latest sources and didn't spot any lambdas in the C++ code with a simple grep. They also don't use auto so I suspect lambda usage is minimal. (It's possible I missed something, I didn't look exhaustively.)

[cor3ntin]

In D124351#4097224, @aaron.ballman wrote:

In D124351#4097192, @dblaikie wrote:

In D124351#4097110, @cor3ntin wrote:

In D124351#4093840, @nikic wrote:

FYI this causes a minor compile-time regression (around 0.35% on 7zip at O0): http://llvm-compile-time-tracker.com/compare.php?from=cd173cbd7cca69c29df42cd4b42e60433435c29b&to=d708a186b6a9b050d09558163dd353d9f738c82d&stat=instructions%3Au

Just wanted to check whether that's expected.

It's certainly not great but not entirely unexpected as we are doing quite a bit more work, although it should only affect code that constructs a lot of distinct lambda.

Does 7zip meet that criteria? As a gut-check that this only costs in that case, would be nice to know if the 7zip regression is that case, or is this the cost even when that isn't true - so we could expect higher costs when it is true?

I just downloaded their latest sources and didn't spot any lambdas in the C++ code with a simple grep. They also don't use auto so I suspect lambda usage is minimal. (It's possible I missed something, I didn't look exhaustively.)

Thanks. Then it's lookup related... I'll have to investigate. Coming up with a meaningful benchmark will be a challenge though.

[rupprecht]

Hi, me again :)

I ran into an interesting build breakage from this, I can't tell if it's a legitimate breakage based on reading P2036R3 and P2579R0 (mostly I'm not a language lawyer).

struct StringLiteral {
  template <int N>
  StringLiteral(const char (&array)[N])
      __attribute__((enable_if(N > 0 && N == __builtin_strlen(array) + 1,
                               "invalid string literal")));
};

struct Message {
  Message(StringLiteral);
};

void Func1() {
  auto x = Message("x");  // Note: this is fine

  // Note: "xx\0" to force a different type, StringLiteral<3>, otherwise this
  // successfully builds.
  auto y = [&](decltype(Message("xx"))) {};

  // ^ fails with: repro.cc:18:13: error: reference to local variable 'array'
  // declared in enclosing function 'StringLiteral::StringLiteral<3>'

  (void)x;
  (void)y;
}

https://godbolt.org/z/M4E6jKxxn

Does this look like an intended breakage from this patch?

[cor3ntin]

In D124351#4101611, @rupprecht wrote:

Hi, me again :)

I ran into an interesting build breakage from this, I can't tell if it's a legitimate breakage based on reading P2036R3 and P2579R0 (mostly I'm not a language lawyer).

struct StringLiteral {
  template <int N>
  StringLiteral(const char (&array)[N])
      __attribute__((enable_if(N > 0 && N == __builtin_strlen(array) + 1,
                               "invalid string literal")));
};

struct Message {
  Message(StringLiteral);
};

void Func1() {
  auto x = Message("x");  // Note: this is fine

  // Note: "xx\0" to force a different type, StringLiteral<3>, otherwise this
  // successfully builds.
  auto y = [&](decltype(Message("xx"))) {};

  // ^ fails with: repro.cc:18:13: error: reference to local variable 'array'
  // declared in enclosing function 'StringLiteral::StringLiteral<3>'

  (void)x;
  (void)y;
}

https://godbolt.org/z/M4E6jKxxn

Does this look like an intended breakage from this patch?

Looks like we fail to enter the appropriate context somewhere (my guess is that it might be specific to the attribute but it's hard to say without picking around), definitely a bug

I'll be away the next 2 weeks, I'll look at it when I get back. Maybe we should track it in an issue though.

[eaeltsin]

Looks like we fail to enter the appropriate context somewhere (my guess is that it might be specific to the attribute but it's hard to say without picking around), definitely a bug

I'll be away the next 2 weeks, I'll look at it when I get back. Maybe we should track it in an issue though.

Should we revert this then?

[aaron.ballman]

In D124351#4102634, @eaeltsin wrote:

Looks like we fail to enter the appropriate context somewhere (my guess is that it might be specific to the attribute but it's hard to say without picking around), definitely a bug

I'll be away the next 2 weeks, I'll look at it when I get back. Maybe we should track it in an issue though.

Should we revert this then?

Yes, I think we should. We should also file an issue so @cor3ntin doesn't lose track of the issue. Anyone want to volunteer to do that? (I can do it early next week otherwise.)

[rupprecht]

In D124351#4102679, @aaron.ballman wrote:

In D124351#4102634, @eaeltsin wrote:

Looks like we fail to enter the appropriate context somewhere (my guess is that it might be specific to the attribute but it's hard to say without picking around), definitely a bug

I'll be away the next 2 weeks, I'll look at it when I get back. Maybe we should track it in an issue though.

Should we revert this then?

Yes, I think we should. We should also file an issue so @cor3ntin doesn't lose track of the issue. Anyone want to volunteer to do that? (I can do it early next week otherwise.)

Done in 74ce297045bac4bc475b8e762d2a1ea19bb16d3c and filed https://github.com/llvm/llvm-project/issues/60518 to track re-landing this.

[aaron.ballman]

In D124351#4102818, @rupprecht wrote:

In D124351#4102679, @aaron.ballman wrote:

In D124351#4102634, @eaeltsin wrote:

Looks like we fail to enter the appropriate context somewhere (my guess is that it might be specific to the attribute but it's hard to say without picking around), definitely a bug

I'll be away the next 2 weeks, I'll look at it when I get back. Maybe we should track it in an issue though.

Should we revert this then?

Yes, I think we should. We should also file an issue so @cor3ntin doesn't lose track of the issue. Anyone want to volunteer to do that? (I can do it early next week otherwise.)

Done in 74ce297045bac4bc475b8e762d2a1ea19bb16d3c and filed https://github.com/llvm/llvm-project/issues/60518 to track re-landing this.

Thank you (and thank you for letting us know about the issue)!

[cor3ntin]

Reopen/Rebase

[cor3ntin]

Fix GH60518 by not trying to capture parameters declared in the current
context.

[aaron.ballman]

clang/lib/Sema/SemaExpr.cpp

18653

Formatting nit.

I have a hazy recollection that we sometimes have a weird declaration context for parameters where the parameter doesn't think it's associated with a function DC but instead with the translation unit DC. I seem to recall this having something to do with PCH/AST importing, but I can't seem to find any open issues about it. So this might be fine, but it may have some weird edge cases still.

clang/test/SemaCXX/lambda-expressions.cpp

675–676 ↗

(On Diff #497994)

1. This code already compiles today without issue (https://godbolt.org/z/q6hPxoWq9), so are you sure this is testing what needs to be tested?

2. What about for non-GNU-style attributes ([[]] attributes that appertain to the function type)? e.g.,

template <int N>
void foo(const char (&array)[N]) [[clang::annotate_type("test", array)]];

[cor3ntin]

clang/lib/Sema/SemaExpr.cpp

18653

Yep, parameters are all created in the top level dc before being attached to the function. but by the time they get to be captured by a lambda they are attached to the function
(default parameters initializers can't capture)

clang/test/SemaCXX/lambda-expressions.cpp

675–676 ↗

(On Diff #497994)

Yes, this is something that was broken by this patch.
enable_if did create odr uses (incorrectly). I can add a test for annotate_type but I don't think it would run into the same issue at all.

[aaron.ballman]

clang/lib/Sema/SemaExpr.cpp

18653

Phew, thanks for checking!

clang/test/SemaCXX/lambda-expressions.cpp

675–676 ↗

(On Diff #497994)

So I'm not certain what's being tested then -- how are you validating that array is no longer ODR used?

In terms of annotate_type, that attribute accepts a string literal followed by a variable number of expression arguments, so I think it should have the same issues as a GNU-style attribute accepting an expression argument. I was mostly trying to wrap my head around whether [[]] and __attribute__ are expected to have different behaviors when written in that position.

[cor3ntin]

clang/test/SemaCXX/lambda-expressions.cpp

675–676 ↗

(On Diff #497994)

Context https://reviews.llvm.org/D124351#4101611

[cor3ntin]

Address Aaron's comments

[aaron.ballman]

LGTM

clang/test/SemaCXX/lambda-expressions.cpp

675–676 ↗

(On Diff #497994)

I talked to @cor3ntin off-list to get a better understanding of the test situation, and I realized the issue was that this code used to give a diagnostic that it shouldn't have, so this is demonstrating we accept the code rather than reject it. That makes a lot more sense now!

[rupprecht]

All the things that were broken before are no longer broken, so LGTM

[shafik]

clang/lib/Parse/ParseExprCXX.cpp

1321–1322

Minor edit

1321–1322

1389

If only we had a diagnostic for that....

1526–1533

This if feels pretty messy maybe refactor into something like CheckHasSpecificers, maybe?

[shafik]

clang/lib/Sema/SemaConcept.cpp

537 ↗

(On Diff #499754)

This is just duplicated across the if and else, please refactor it out. If this ever gets modified folks have to fix it in both places and that is easy to mess up.

[shafik]

clang/lib/Sema/SemaExpr.cpp

18581

We have a bunch of bugs that crash in the method and it would be good to rescreen those bugs after landing this to see if it fixes any of those.

clang/lib/Sema/SemaLambda.cpp

977

This has changed a bit so might be worth updating the wording here to reflect C++20.

989–991

minor fix

1019

1022

Same as comment above about updating wording to reflect C++20.

1244–1245

clang/lib/Sema/TreeTransform.h

12985

[cor3ntin]

Address Shafik's comments

[cor3ntin]

@rupprecht Great to hear! Sorry again for the disruption
@shafik Thanks for the review!

clang/lib/Sema/SemaLambda.cpp

1022

I don't even think we should repeat that comment here.

[cor3ntin]

@shafik Can you let me know if you are happy with the changes i made to address your feedback? Thanks!

[shafik]

LGTM

[sammccall]

We're seeing new clang crashes that bisect to this commit, with modules only.

I have it mostly-reduced and will post shortly, trying to see if I can simplify any further (since modules reproducers are a pain).

Meanwhile, the assert/stack in case it's already useful:

assertion failed at third_party/llvm/llvm-project/clang/lib/Sema/SemaTemplateInstantiate.cpp:4065 in llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *clang::LocalInstantiationScope::findInstantiationOf(const Decl *): isa<LabelDecl>(D) && "declaration not instantiated in this scope"
*** Check failure stack trace: ***
    @     0x5609e4f16f44  __assert_fail
    @     0x5609e1894234  clang::LocalInstantiationScope::findInstantiationOf()
    @     0x5609e18d073c  clang::Sema::FindInstantiatedDecl()
    @     0x5609e18a99d0  clang::TreeTransform<>::TransformLambdaExpr()
    @     0x5609e189dbee  (anonymous namespace)::TemplateInstantiator::TransformLambdaExpr()
    @     0x5609e1892442  clang::TreeTransform<>::TransformExprs()
    @     0x5609e189a71a  clang::TreeTransform<>::TransformCallExpr()
    @     0x5609e189097a  clang::TreeTransform<>::TransformStmt()
    @     0x5609e18afa54  clang::TreeTransform<>::TransformCompoundStmt()
    @     0x5609e1890902  clang::Sema::SubstStmt()
    @     0x5609e18e31df  clang::Sema::InstantiateFunctionDefinition()
    @     0x5609e18e5ed2  clang::Sema::PerformPendingInstantiations()
    @     0x5609e0fcad44  clang::Sema::ActOnEndOfTranslationUnitFragment()
    @     0x5609e0fcbb66  clang::Sema::ActOnEndOfTranslationUnit()
    @     0x5609e0d298e6  clang::Parser::ParseTopLevelDecl()
    @     0x5609e0d2388e  clang::ParseAST()
    @     0x5609e0a647c3  clang::FrontendAction::Execute()
    @     0x5609e09d81ad  clang::CompilerInstance::ExecuteAction()
    @     0x5609dfa05b08  clang::ExecuteCompilerInvocation()
    @     0x5609df9f99f1  cc1_main()
    @     0x5609df9f5d28  ExecuteCC1Tool()
    @     0x5609e0b868be  llvm::function_ref<>::callback_fn<>()
    @     0x5609e4d9ec35  llvm::CrashRecoveryContext::RunSafely()
    @     0x5609e0b86103  clang::driver::CC1Command::Execute()
    @     0x5609e0b44166  clang::driver::Compilation::ExecuteCommand()
    @     0x5609e0b4448f  clang::driver::Compilation::ExecuteJobs()
    @     0x5609e0b63e70  clang::driver::Driver::ExecuteCompilation()
    @     0x5609df9f4ee7  clang_main()
    @     0x5609df9f1bc4  main
    @     0x7fad2cda4633  __libc_start_main
    @     0x5609df9f1b2a  _start

[cor3ntin]

In D124351#4175717, @sammccall wrote:

We're seeing new clang crashes that bisect to this commit, with modules only.

I have it mostly-reduced and will post shortly, trying to see if I can simplify any further (since modules reproducers are a pain).

Meanwhile, the assert/stack in case it's already useful:

assertion failed at third_party/llvm/llvm-project/clang/lib/Sema/SemaTemplateInstantiate.cpp:4065 in llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *clang::LocalInstantiationScope::findInstantiationOf(const Decl *): isa<LabelDecl>(D) && "declaration not instantiated in this scope"
*** Check failure stack trace: ***
    @     0x5609e4f16f44  __assert_fail
    @     0x5609e1894234  clang::LocalInstantiationScope::findInstantiationOf()
    @     0x5609e18d073c  clang::Sema::FindInstantiatedDecl()
    @     0x5609e18a99d0  clang::TreeTransform<>::TransformLambdaExpr()
    @     0x5609e189dbee  (anonymous namespace)::TemplateInstantiator::TransformLambdaExpr()
    @     0x5609e1892442  clang::TreeTransform<>::TransformExprs()
    @     0x5609e189a71a  clang::TreeTransform<>::TransformCallExpr()
    @     0x5609e189097a  clang::TreeTransform<>::TransformStmt()
    @     0x5609e18afa54  clang::TreeTransform<>::TransformCompoundStmt()
    @     0x5609e1890902  clang::Sema::SubstStmt()
    @     0x5609e18e31df  clang::Sema::InstantiateFunctionDefinition()
    @     0x5609e18e5ed2  clang::Sema::PerformPendingInstantiations()
    @     0x5609e0fcad44  clang::Sema::ActOnEndOfTranslationUnitFragment()
    @     0x5609e0fcbb66  clang::Sema::ActOnEndOfTranslationUnit()
    @     0x5609e0d298e6  clang::Parser::ParseTopLevelDecl()
    @     0x5609e0d2388e  clang::ParseAST()
    @     0x5609e0a647c3  clang::FrontendAction::Execute()
    @     0x5609e09d81ad  clang::CompilerInstance::ExecuteAction()
    @     0x5609dfa05b08  clang::ExecuteCompilerInvocation()
    @     0x5609df9f99f1  cc1_main()
    @     0x5609df9f5d28  ExecuteCC1Tool()
    @     0x5609e0b868be  llvm::function_ref<>::callback_fn<>()
    @     0x5609e4d9ec35  llvm::CrashRecoveryContext::RunSafely()
    @     0x5609e0b86103  clang::driver::CC1Command::Execute()
    @     0x5609e0b44166  clang::driver::Compilation::ExecuteCommand()
    @     0x5609e0b4448f  clang::driver::Compilation::ExecuteJobs()
    @     0x5609e0b63e70  clang::driver::Driver::ExecuteCompilation()
    @     0x5609df9f4ee7  clang_main()
    @     0x5609df9f1bc4  main
    @     0x7fad2cda4633  __libc_start_main
    @     0x5609df9f1b2a  _start

Thanks for letting me know.
A reproduction will be very useful to track that down indeed, I'll look into it as soon as i hear back from you. The stack trace doesn't tell me much unfortunately, although it definitely appears related.

[sammccall]

Sorry for the delay, extracting the repro from the build system seems about as much work as minimizing it :-)

modrepo2.zip2 KBDownload

- running repro.sh hits an assert for me on the main.cpp compile.

(I suspect something much smaller is breaking the expected invariant, I just can't get a smaller crasher)

[cor3ntin]

In D124351#4178334, @sammccall wrote:

Sorry for the delay, extracting the repro from the build system seems about as much work as minimizing it :-)

modrepo2.zip2 KBDownload

- running repro.sh hits an assert for me on the main.cpp compile.

(I suspect something much smaller is breaking the expected invariant, I just can't get a smaller crasher)

@ChuanqiXu @erichkeane I started to look at this repro but I might need help, it seems extremely weird (I failed to reduce it much further), and I don't have a good grasp on how modules affect things

[aaron.ballman]

In D124351#4179510, @cor3ntin wrote:

In D124351#4178334, @sammccall wrote:

Sorry for the delay, extracting the repro from the build system seems about as much work as minimizing it :-)

modrepo2.zip2 KBDownload

- running repro.sh hits an assert for me on the main.cpp compile.

(I suspect something much smaller is breaking the expected invariant, I just can't get a smaller crasher)

@ChuanqiXu @erichkeane I started to look at this repro but I might need help, it seems extremely weird (I failed to reduce it much further), and I don't have a good grasp on how modules affect things

I'm trying to help out here as well, but in addition to @ChuanqiXu and @erichkeane, I wonder if @iains or @urnathan have ideas as well (they've both done modules work before).

[aaron.ballman]

Please keep in mind that I don't have a lot of expertise in modules, but this sure seems like a modules bug from what I can tell, and it might even relate to work happening in D145737 (CC @rsmith). That patch does not seem to address this issue, but what I'm seeing when I try to debug this is a bit confusing to me:

In the reproducer from Sam, there are three lambdas:
create::Create<R>([] {}); in main.cpp, but this does not participate in AST merging because it's within the main source file
BuildWidget<T>([dummy](Widget<T>*) {}); in create.h
create::Create<float>([] {}); in instantiate_create.h

There are two modules involved (wrap_create and instantiate_create). I would expect the wrap_create module to contain one lambda (from including create.h) and the instantiate_create module to contain two lambdas (one from InstantiateCreate() and one from including create.h).

So I would expect ASTDeclReader::ReadCXXDefinitionData() to find three lambdas, but instead it finds *four*. The first lambda it reads is the one in InstantiateCreate(). The next three all have captures of dummy; the first two come from the instantiate_create module and the last one comes from the wrap_create module.

[rsmith]

In D124351#4185007, @aaron.ballman wrote:

In the reproducer from Sam, there are three lambdas:
create::Create<R>([] {}); in main.cpp, but this does not participate in AST merging because it's within the main source file
BuildWidget<T>([dummy](Widget<T>*) {}); in create.h

There should be three of these in total: one from wrap_create.h's textual inclusion of create.h, one from instantiate_create.h's textual inclusion of create.h, and one from instantiate_create.h's instantiation of Create<float>. The first two should get merged together if they're both loaded. This runs into some issues, because the local dummy variable in the two different bodies of the Create template don't get merged. In rG4a1ccfe8a3cfd4569bc962a38b6117a9a2b8ad21 I attempted to fix that by tracking all the lists of captures from different merged copies of the lambdas, so we can find the right way to name (eg) dummy in the enclosing context. Possibly some more work is needed here, to make template instantiation look through that list when instantiating a reference to a declaration, in the case where we pick a lambda body from one module but pick the enclosing function's body from a different module.

The first lambda it reads is the one in InstantiateCreate(). The next three all have captures of dummy; the first two come from the instantiate_create module and the last one comes from the wrap_create module.

That sounds right to me. One of the ones from instantiate_create (the one taking Widget<T>*, not the one taking Widget<float>*) should be merged with the one from wrap_create.h.

clang/lib/Sema/SemaCXXScopeSpec.cpp

295–298

Will this also reject __super in a local class inside a lambda? That seems like something we should still permit.

[cor3ntin]

clang/lib/Sema/SemaCXXScopeSpec.cpp

295–298

https://godbolt.org/z/dEj3vG8nc
Seems to work fine -

In both cases we create a non capturing function scope so getCurLambda returns nullptr

[ChuanqiXu]

It looks like that the Create template functions get merged expectedly. And the dummy variable shouldn't get merged since it is not in a mergeable primary context (function context is not a mergeable primary context) (see https://github.com/llvm/llvm-project/blob/23bd0e037b744d1f93bdfad59b7575017725a96c/clang/lib/Serialization/ASTReaderDecl.cpp#L3107-L3151).

When I remove the use of dummy in the captures list, https://github.com/llvm/llvm-project/blob/23bd0e037b744d1f93bdfad59b7575017725a96c/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp#L6079 is not executed. No matter if the dummy variable is captured or not, https://github.com/llvm/llvm-project/blob/23bd0e037b744d1f93bdfad59b7575017725a96c/clang/lib/Sema/SemaTemplateInstantiate.cpp#L4069-L4088 will execute twice for the dummy variable.

[eandrews]

This patch causes an assertion when the attribute argument is an integer constant expression - https://godbolt.org/z/osKx5ejMb and has resulted in test fails downstream since any attribute which uses VerifyIntegerConstantExpression now hits this assert if used with lambdas.

The assert hit is in getCurLambda() :

auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
 if (CurLSI && CurLSI->Lambda && CurLSI->CallOperator &&
     !CurLSI->Lambda->Encloses(CurContext) && CurLSI->AfterParameterList) {
   // We have switched contexts due to template instantiation.
   assert(!CodeSynthesisContexts.empty()); <----- Hits this
   return nullptr;
 }

Prior to this patch, Lambda Scope Information was not populated till after semantic analysis of attributes. This meant CurLSI->Lambda returned nullptr and we never entered the if. This patch however populates LSI during semantic analysis of lambda expression after introducer, which means we now enter the if during semantic analysis of the attribute` (AfterParameterList will be true at this point since this assert is hit way past parsing the parameters. CurContext is foo. I don't know if CurContext is right/wrong without further debugging.)

For the godbolt test pasted above, neither before nor after this patch do we hit the code where CodeSynthesisContexts is populated. I wanted to see what code actually enters that block and so I tried deleting the code to see what tests fails. What is interesting is that nothing does :/ So I don't know if that means our tests are incomplete or if this code is not required.

[cor3ntin]

In D124351#4207501, @eandrews wrote:

This patch causes an assertion when the attribute argument is an integer constant expression - https://godbolt.org/z/osKx5ejMb and has resulted in test fails downstream since any attribute which uses VerifyIntegerConstantExpression now hits this assert if used with lambdas.

The assert hit is in getCurLambda() :

auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
 if (CurLSI && CurLSI->Lambda && CurLSI->CallOperator &&
     !CurLSI->Lambda->Encloses(CurContext) && CurLSI->AfterParameterList) {
   // We have switched contexts due to template instantiation.
   assert(!CodeSynthesisContexts.empty()); <----- Hits this
   return nullptr;
 }

Prior to this patch, Lambda Scope Information was not populated till after semantic analysis of attributes. This meant CurLSI->Lambda returned nullptr and we never entered the if. This patch however populates LSI during semantic analysis of lambda expression after introducer, which means we now enter the if during semantic analysis of the attribute` (AfterParameterList will be true at this point since this assert is hit way past parsing the parameters. CurContext is foo. I don't know if CurContext is right/wrong without further debugging.)

For the godbolt test pasted above, neither before nor after this patch do we hit the code where CodeSynthesisContexts is populated. I wanted to see what code actually enters that block and so I tried deleting the code to see what tests fails. What is interesting is that nothing does :/ So I don't know if that means our tests are incomplete or if this code is not required.

Thanks :)
As far i could tell, this check is only there to catch developer mistakes. We could probably hide it under #ifndef NDEBUG - seems preferable than to remove it entirely - and then make sure AfterParameterList is appropriately set to false when parsing GNU attributes. I might have time to look into it later today if you don't.

[eandrews]

In D124351#4208842, @cor3ntin wrote:

In D124351#4207501, @eandrews wrote:

This patch causes an assertion when the attribute argument is an integer constant expression - https://godbolt.org/z/osKx5ejMb and has resulted in test fails downstream since any attribute which uses VerifyIntegerConstantExpression now hits this assert if used with lambdas.

The assert hit is in getCurLambda() :

auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
 if (CurLSI && CurLSI->Lambda && CurLSI->CallOperator &&
     !CurLSI->Lambda->Encloses(CurContext) && CurLSI->AfterParameterList) {
   // We have switched contexts due to template instantiation.
   assert(!CodeSynthesisContexts.empty()); <----- Hits this
   return nullptr;
 }

Prior to this patch, Lambda Scope Information was not populated till after semantic analysis of attributes. This meant CurLSI->Lambda returned nullptr and we never entered the if. This patch however populates LSI during semantic analysis of lambda expression after introducer, which means we now enter the if during semantic analysis of the attribute` (AfterParameterList will be true at this point since this assert is hit way past parsing the parameters. CurContext is foo. I don't know if CurContext is right/wrong without further debugging.)

For the godbolt test pasted above, neither before nor after this patch do we hit the code where CodeSynthesisContexts is populated. I wanted to see what code actually enters that block and so I tried deleting the code to see what tests fails. What is interesting is that nothing does :/ So I don't know if that means our tests are incomplete or if this code is not required.

Thanks :)
then make sure AfterParameterList is appropriately set to false when parsing GNU attributes. I might have time to look into it later today if you don't.

I did look into AfterParameterList a bit yesterday. I don't fully understand this PR yet and so I could be wrong, but I think it is handled correctly at the moment. This assert is hit during semantic analysis of attributes (i.e. ProcessDeclAttributes in ActOnLambdaDefinition). Shouldn't AfterParameterList be true at this point (like it is now)?

By the way we see this crash with some of our clang attributes downstream as well.

As far i could tell, this check is only there to catch developer mistakes. We could probably hide it under #ifndef NDEBUG - seems preferable than to remove it entirely

Any attribute which takes the VerifyIntegerConstantExpression path fails. Since this assert is hit for valid code, I do think it needs to be fixed because valid code will fail in debug build even if we hide it under NDEBUG. If you can look into it today, that would be great!

clang/docs/ReleaseNotes.rst

- The mangling scheme for C++20 modules has incompatibly changed. The
   ownership design decision did not give the backwards compatibility
   that was hoped for. C++20 since added ``extern "C++"`` semantics
   that can be used for such compatibility. The demangler now demangles
   symbols with named module attachment.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Implemented `P2128R6: Multidimensional subscript operator <https://wg21.link/P2128R6>`_.
 - Implemented `P0849R8: auto(x): decay-copy in the language <https://wg21.link/P0849R8>`_.
 - Implemented `P2242R3: Non-literal variables (and labels and gotos) in constexpr functions <https://wg21.link/P2242R3>`_.
+- Implemented `P2036R3: Change scope of lambda trailing-return-type <https://wg21.link/P2036R3>`_.
+  This proposal modifies how variables captured in lambdas can appear in trailing return type
+  expressions and how their types are deduced therein, in all C++ language versions.
 
 CUDA Language Changes in Clang
 ------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------
 
 OpenCL C Language Changes in Clang
 ----------------------------------

clang/include/clang/AST/DeclCXX.h

if (!isLambda())
       return LDK_Unknown;
     return getLambdaData().DependencyKind;
   }
 
   TypeSourceInfo *getLambdaTypeInfo() const {
     return getLambdaData().MethodTyInfo;
   }
 
+  void setLambdaTypeInfo(TypeSourceInfo *TS) {
+    auto *DD = DefinitionData;
+    assert(DD && DD->IsLambda && "setting lambda property of non-lambda class");
+    auto &DL = static_cast<LambdaDefinitionData &>(*DD);
+    DL.MethodTyInfo = TS;
+  }
+
+  void setLambdaIsGeneric(bool IsGeneric) {
+    auto *DD = DefinitionData;
+    assert(DD && DD->IsLambda && "setting lambda property of non-lambda class");
+    auto &DL = static_cast<LambdaDefinitionData &>(*DD);
+    DL.IsGenericLambda = IsGeneric;
+  }
+
   // Determine whether this type is an Interface Like type for
   // __interface inheritance purposes.
   bool isInterfaceLike() const;
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
     return K >= firstCXXRecord && K <= lastCXXRecord;
   }

clang/include/clang/Basic/DiagnosticSemaKinds.td

let CategoryName = "Lambda Issue" in {
   def err_lambda_capture_anonymous_var : Error<
     "unnamed variable cannot be implicitly captured in a lambda expression">;
   def err_lambda_capture_flexarray_type : Error<
     "variable %0 with flexible array member cannot be captured in "
     "a lambda expression">;
   def err_lambda_impcap : Error<
     "variable %0 cannot be implicitly captured in a lambda with no "
     "capture-default specified">;
+  def err_lambda_used_before_capture: Error<
+    "captured variable %0 cannot appear here">;
   def note_lambda_variable_capture_fixit : Note<
     "capture %0 by %select{value|reference}1">;
   def note_lambda_default_capture_fixit : Note<
     "default capture by %select{value|reference}0">;
   def note_lambda_decl : Note<"lambda expression begins here">;
   def err_lambda_unevaluated_operand : Error<
     "lambda expression in an unevaluated operand">;
   def err_lambda_in_constant_expression : Error<

clang/include/clang/Parse/Parser.h

private:
   };
 
   // [...] () -> type {...}
   ExprResult ParseLambdaExpression();
   ExprResult TryParseLambdaExpression();
   bool
   ParseLambdaIntroducer(LambdaIntroducer &Intro,
                         LambdaIntroducerTentativeParse *Tentative = nullptr);
+  SourceLocation LambdaLookAheadMutableSpecifier();
   ExprResult ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro);
+  void ParseLambdaLexedGNUAttributeArgs(LateParsedAttribute &LA,
+                                        ParsedAttributes &Attrs, Declarator &D);
 
   //===--------------------------------------------------------------------===//
   // C++ 5.2p1: C++ Casts
   ExprResult ParseCXXCasts();
 
   /// Parse a __builtin_bit_cast(T, E), used to implement C++2a std::bit_cast.
   ExprResult ParseBuiltinBitCast();
 

clang/include/clang/Sema/Scope.h

 /// declaration.
 class Scope {
 public:
   /// ScopeFlags - These are bitfields that are or'd together when creating a
   /// scope, which defines the sorts of things the scope contains.
   enum ScopeFlags {
     /// This indicates that the scope corresponds to a function, which
     /// means that labels are set here.
-    FnScope       = 0x01,
+    FnScope = 0x01,
 
     /// This is a while, do, switch, for, etc that can have break
     /// statements embedded into it.
-    BreakScope    = 0x02,
+    BreakScope = 0x02,
 
     /// This is a while, do, for, which can have continue statements
     /// embedded into it.
     ContinueScope = 0x04,
 
     /// This is a scope that can contain a declaration.  Some scopes
     /// just contain loop constructs but don't contain decls.
     DeclScope = 0x08,
enum ScopeFlags {
 
     /// This is the scope of a C++ catch statement.
     CatchScope = 0x1000000,
 
     /// This is a scope in which a condition variable is currently being
     /// parsed. If such a scope is a ContinueScope, it's invalid to jump to the
     /// continue block from here.
     ConditionVarScope = 0x2000000,
+
+    /// This is the scope for a lambda, after the lambda introducer.
+    /// Lambdas need 2 FunctionPrototypeScope scopes (because there is a
+    /// template scope in between), the outer scope does not increase the
+    /// depth of recursion.
+    LambdaScope = 0x4000000,
   };
 
 private:
   /// The parent scope for this scope.  This is null for the translation-unit
   /// scope.
   Scope *AnyParent;
 
   /// Flags - This contains a set of ScopeFlags, which indicates how the scope

clang/include/clang/Sema/ScopeInfo.h

class LambdaScopeInfo final :
     public CapturingScopeInfo, public InventedTemplateParameterInfo {
 public:
   /// The class that describes the lambda.
   CXXRecordDecl *Lambda = nullptr;
 
   /// The lambda's compiler-generated \c operator().
   CXXMethodDecl *CallOperator = nullptr;
 
+  struct DelayedCapture {
+    VarDecl *Var;
+    SourceLocation Loc;
+    LambdaCaptureKind Kind;
+  };
+
+  /// Holds the captures until we parsed the qualifiers, as the cv qualified
+  /// type of captures can only be computed at that point, and the captures
+  /// should not be visible before.
+  /// The index represents the position in the original capture list.
+  /// We use a map as not all index represents captures (defaults), or are
+  /// captured (some captures are invalid).
+  llvm::DenseMap<unsigned, DelayedCapture> DelayedCaptures;
+
+  /// Whether the current scope when parsing the lambda
+  /// is after the call operator qualifiers,
+  /// which is the point at which the captures are usable
+  /// per [expr.prim.id.unqual]/p3.2 and [expr.prim.lambda.capture]/6.
+  /// This is set to false by default as the lambda can be reconstructed during
+  /// instantiation
+  bool HasKnownMutability = true;
+  bool AfterParameterList = true;
+
   /// Source range covering the lambda introducer [...].
   SourceRange IntroducerRange;
 
   /// Source location of the '&' or '=' specifying the default capture
   /// type, if any.
   SourceLocation CaptureDefaultLoc;
 
   /// The number of captures in the \c Captures list that are
   /// explicit captures.
   unsigned NumExplicitCaptures = 0;
 
   /// Whether this is a mutable lambda.
   bool Mutable = false;
 
   /// Whether the (empty) parameter list is explicit.
   bool ExplicitParams = false;
 
   /// Whether any of the capture expressions requires cleanups.
   CleanupInfo Cleanup;
 
   /// Whether the lambda contains an unexpanded parameter pack.
   bool ContainsUnexpandedParameterPack = false;

clang/include/clang/Sema/Sema.h

public:
   void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
 
   /// Create a new lambda closure type.
   CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
                                          TypeSourceInfo *Info,
                                          unsigned LambdaDependencyKind,
                                          LambdaCaptureDefault CaptureDefault);
 
-  /// Start the definition of a lambda expression.
-  CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
-                                       SourceRange IntroducerRange,
-                                       TypeSourceInfo *MethodType,
-                                       SourceLocation EndLoc,
-                                       ArrayRef<ParmVarDecl *> Params,
-                                       ConstexprSpecKind ConstexprKind,
-                                       Expr *TrailingRequiresClause);
-
   /// Number lambda for linkage purposes if necessary.
   void handleLambdaNumbering(
       CXXRecordDecl *Class, CXXMethodDecl *Method,
       Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
 
   /// Endow the lambda scope info with the relevant properties.
   void buildLambdaScope(sema::LambdaScopeInfo *LSI,
                         CXXMethodDecl *CallOperator,
                         SourceRange IntroducerRange,
                         LambdaCaptureDefault CaptureDefault,
                         SourceLocation CaptureDefaultLoc,
                         bool ExplicitParams,
-                        bool ExplicitResultType,
                         bool Mutable);
 
+  CXXMethodDecl *CreateLambdaCallOperator(SourceRange IntroducerRange,
+                                          CXXRecordDecl *Class);
+  void CompleteLambdaCallOperator(
+      CXXMethodDecl *Method, SourceLocation LambdaLoc,
+      SourceLocation CallOperatorLoc, Expr *TrailingRequiresClause,
+      TypeSourceInfo *MethodTyInfo, ConstexprSpecKind ConstexprKind,
+      ArrayRef<ParmVarDecl *> Params, bool HasExplicitResultType);
+
   /// Perform initialization analysis of the init-capture and perform
   /// any implicit conversions such as an lvalue-to-rvalue conversion if
   /// not being used to initialize a reference.
   ParsedType actOnLambdaInitCaptureInitialization(
       SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
       IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {
     return ParsedType::make(buildLambdaInitCaptureInitialization(
         Loc, ByRef, EllipsisLoc, None, Id,
         InitKind != LambdaCaptureInitKind::CopyInit, Init));
   }
   QualType buildLambdaInitCaptureInitialization(
       SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
       Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,
       Expr *&Init);
 
   /// Create a dummy variable within the declcontext of the lambda's
   ///  call operator, for name lookup purposes for a lambda init capture.
   ///
   ///  CodeGen handles emission of lambda captures, ignoring these dummy
   ///  variables appropriately.
-  VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
-                                          QualType InitCaptureType,
-                                          SourceLocation EllipsisLoc,
-                                          IdentifierInfo *Id,
-                                          unsigned InitStyle, Expr *Init);
+  VarDecl *createLambdaInitCaptureVarDecl(
+      SourceLocation Loc, QualType InitCaptureType, SourceLocation EllipsisLoc,
+      IdentifierInfo *Id, unsigned InitStyle, Expr *Init, DeclContext *DeclCtx);
 
   /// Add an init-capture to a lambda scope.
   void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);
 
   /// Note that we have finished the explicit captures for the
   /// given lambda.
   void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
 
-  /// \brief This is called after parsing the explicit template parameter list
+  /// Deduce a block or lambda's return type based on the return
+  /// statements present in the body.
+  void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
+
+  /// Once the Lambdas capture are known, we can
+  /// start to create the closure, call operator method,
+  /// and keep track of the captures.
+  /// We do the capture lookup here, but they are not actually captured
+  /// until after we know what the qualifiers of the call operator are.
+  void ActOnLambdaIntroducer(LambdaIntroducer &Intro, Scope *CurContext);
+
+  /// This is called after parsing the explicit template parameter list
   /// on a lambda (if it exists) in C++2a.
-  void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
+  void ActOnLambdaExplicitTemplateParameterList(LambdaIntroducer &Intro,
+                                                SourceLocation LAngleLoc,
                                                 ArrayRef<NamedDecl *> TParams,
                                                 SourceLocation RAngleLoc,
                                                 ExprResult RequiresClause);
 
-  /// Introduce the lambda parameters into scope.
-  void addLambdaParameters(
-      ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
-      CXXMethodDecl *CallOperator, Scope *CurScope);
+  void ActOnLambdaClosureQualifiers(LambdaIntroducer &Intro,
+                                    SourceLocation MutableLoc);
 
-  /// Deduce a block or lambda's return type based on the return
-  /// statements present in the body.
-  void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
+  void ActOnLambdaClosureParameters(
+      Scope *LambdaScope,
+      MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo);
 
   /// ActOnStartOfLambdaDefinition - This is called just before we start
   /// parsing the body of a lambda; it analyzes the explicit captures and
   /// arguments, and sets up various data-structures for the body of the
   /// lambda.
   void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
-                                    Declarator &ParamInfo, Scope *CurScope);
+                                    Declarator &ParamInfo, const DeclSpec &DS);
 
   /// ActOnLambdaError - If there is an error parsing a lambda, this callback
   /// is invoked to pop the information about the lambda.
   void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
                         bool IsInstantiation = false);
 
   /// ActOnLambdaExpr - This is called when the body of a lambda expression
   /// was successfully completed.
private:
   /// instantiation scope, and set the parameter names to those used
   /// in the template.
   bool addInstantiatedParametersToScope(
       FunctionDecl *Function, const FunctionDecl *PatternDecl,
       LocalInstantiationScope &Scope,
       const MultiLevelTemplateArgumentList &TemplateArgs);
 
 public:
   const NormalizedConstraint *
   getNormalizedAssociatedConstraints(
       NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
 
   /// \brief Check whether the given declaration's associated constraints are
   /// at least as constrained than another declaration's according to the
   /// partial ordering of constraints.
   ///
   /// \param Result If no error occurred, receives the result of true if D1 is

clang/lib/Parse/ParseExprCXX.cpp

static void tryConsumeLambdaSpecifierToken(Parser &P,
 
   while (true) {
     switch (P.getCurToken().getKind()) {
     case tok::kw_mutable: {
       if (MutableLoc.isValid()) {
         P.Diag(P.getCurToken().getLocation(),
                diag::err_lambda_decl_specifier_repeated)
             << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
+      } else {
+        MutableLoc = P.getCurToken().getLocation();
       }
-      MutableLoc = P.ConsumeToken();
-      DeclEndLoc = MutableLoc;
+      DeclEndLoc = P.ConsumeToken();
       break /*switch*/;
     }
     case tok::kw_constexpr:
       if (ConstexprLoc.isValid()) {
         P.Diag(P.getCurToken().getLocation(),
                diag::err_lambda_decl_specifier_repeated)
             << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
       }
if (ConstevalLoc.isValid()) {
     unsigned DiagID = 0;
     DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
                         DiagID);
     if (DiagID != 0)
       P.Diag(ConstevalLoc, DiagID) << PrevSpec;
   }
 }
 
+void Parser::ParseLambdaLexedGNUAttributeArgs(LateParsedAttribute &LA,
+                                              ParsedAttributes &Attrs,
+                                              Declarator &D) {
+  // Create a fake EOF so that attribute parsing won't go off the end of the
+  // attribute.
+  Token AttrEnd;
+  AttrEnd.startToken();
+  AttrEnd.setKind(tok::eof);
+  AttrEnd.setLocation(Tok.getLocation());
+  AttrEnd.setEofData(LA.Toks.data());
+  LA.Toks.push_back(AttrEnd);
+  // Append the current token at the end of the new token stream so that it
+  // doesn't get lost.
+  LA.Toks.push_back(Tok);
+  PP.EnterTokenStream(LA.Toks, true, /*IsReinject=*/true);
+  // Consume the previously pushed token.
+  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
+
+  ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, nullptr, nullptr,
+                        SourceLocation(), ParsedAttr::AS_GNU, &D);
+  // After parsing attribute arguments, we've either reached the EOF token
+  // (signaling that parsing was successful) or we have tokens we need to
+  // consume until we reach the EOF.
+  while (Tok.isNot(tok::eof))
+    ConsumeAnyToken();
+
+  assert(Tok.is(tok::eof));
+  ConsumeAnyToken();
+}
+
+/// LambdaMayHaveMutableSpecifier Look ahead to see if the lkambda will be
+/// mutable
+/// \returns true on success and false if the token was not balanced
+SourceLocation Parser::LambdaLookAheadMutableSpecifier() {
+  assert(Tok.is(tok::l_paren) && "expected the start of a lambda parameter");
+  RevertingTentativeParsingAction RAII(*this);
+  // skip the parameter list
+  ConsumeParen();
+  if (!SkipUntil(tok::r_paren))
+    return SourceLocation{};
+  // skip GNU/MSVC attributes
+  while (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec)) {
+    ConsumeToken();
+    if (!Tok.is(tok::l_paren))
+      return SourceLocation{};
+    ConsumeParen();
+    if (!SkipUntil(tok::r_paren))
+      return SourceLocation{};
+  }
+  while (Tok.isOneOf(tok::kw_constexpr, tok::kw_consteval))
+    ConsumeToken();
+  if (Tok.is(tok::kw_mutable))
+    return Tok.getLocation();
+  return SourceLocation{};
+}
+
 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
 /// expression.
 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                      LambdaIntroducer &Intro) {
   SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
   Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
 
   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
                                 "lambda expression parsing");
 
 
 
   // FIXME: Call into Actions to add any init-capture declarations to the
   // scope while parsing the lambda-declarator and compound-statement.
 
   // Parse lambda-declarator[opt].
   DeclSpec DS(AttrFactory);
   Declarator D(DS, DeclaratorContext::LambdaExpr);
   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
+
+  ParseScope LambdaScope(this, Scope::LambdaScope | Scope::DeclScope |
+                                   Scope::FunctionDeclarationScope |
+                                   Scope::FunctionPrototypeScope);
+
   Actions.PushLambdaScope();
+  Actions.ActOnLambdaIntroducer(Intro, getCurScope());
 
-  ParsedAttributes Attr(AttrFactory);
+  ParsedAttributes Attributes(AttrFactory);
   if (getLangOpts().CUDA) {
     // In CUDA code, GNU attributes are allowed to appear immediately after the
     // "[...]", even if there is no "(...)" before the lambda body.
     MaybeParseGNUAttributes(D);
   }
 
   // Helper to emit a warning if we see a CUDA host/device/global attribute
   // after '(...)'. nvcc doesn't accept this.
   auto WarnIfHasCUDATargetAttr = [&] {
     if (getLangOpts().CUDA)
-      for (const ParsedAttr &A : Attr)
+      for (const ParsedAttr &A : Attributes)
         if (A.getKind() == ParsedAttr::AT_CUDADevice ||
             A.getKind() == ParsedAttr::AT_CUDAHost ||
             A.getKind() == ParsedAttr::AT_CUDAGlobal)
           Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position)
               << A.getAttrName()->getName();
   };
 
   MultiParseScope TemplateParamScope(*this);
if (TemplateParams.empty()) {
         RequiresClause =
             Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
                 /*IsTrailingRequiresClause=*/false));
         if (RequiresClause.isInvalid())
           SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch);
       }
 
       Actions.ActOnLambdaExplicitTemplateParameterList(
-          LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
+          Intro, LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
       ++CurTemplateDepthTracker;
     }
   }
 
   // Implement WG21 P2173, which allows attributes immediately before the
   // lambda declarator and applies them to the corresponding function operator
   // or operator template declaration. We accept this as a conforming extension
   // in all language modes that support lambdas.
   if (isCXX11AttributeSpecifier()) {
     Diag(Tok, getLangOpts().CPlusPlus2b
                   ? diag::warn_cxx20_compat_decl_attrs_on_lambda
                   : diag::ext_decl_attrs_on_lambda);
     MaybeParseCXX11Attributes(D);
   }
 
   TypeResult TrailingReturnType;
   SourceLocation TrailingReturnTypeLoc;
+  SourceLocation LParenLoc, RParenLoc;
+  SourceLocation DeclEndLoc;
+  bool HasParentheses = false;
+  bool HasSpecifiers = false;
+  SourceLocation MutableLoc;
+  LateParsedAttrList LateParsedAttrs(true);
 
-  auto ParseLambdaSpecifiers =
-      [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
-          MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
-          SourceLocation EllipsisLoc) {
-        SourceLocation DeclEndLoc = RParenLoc;
-
-        // GNU-style attributes must be parsed before the mutable specifier to
-        // be compatible with GCC. MSVC-style attributes must be parsed before
-        // the mutable specifier to be compatible with MSVC.
-        MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
-
-        // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
-        // the DeclEndLoc.
-        SourceLocation MutableLoc;
-        SourceLocation ConstexprLoc;
-        SourceLocation ConstevalLoc;
-        tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
-                                       ConstevalLoc, DeclEndLoc);
+  auto ParseConstexprAndMutableSpecifiers = [&] {
+    // However, because GNU attributes could refer to captured variables,
+    // which only become visible after the mutable keyword is parsed
+    // we delay the parsing of gnu attributes - by reusing the mechanism used
+    // for C++ late method parsing. Note, __declspec attributes do not make
+    // use of late parsing (expressions cannot appear in __declspec arguments),
+    // so only GNU style attributes are affected here.
+    MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attributes,
+                         &LateParsedAttrs);
+    SourceLocation CheckMutableLoc;
+
+    tryConsumeLambdaSpecifierToken(*this, CheckMutableLoc, ConstexprLoc,
 
-        addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
-        addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
+
+    assert((MutableLoc.isInvalid() || CheckMutableLoc == MutableLoc) &&
+           "inconsistent mutable specifier in lambda expression");
+    MutableLoc = CheckMutableLoc;
+  };
+
+  auto ParseLambdaSpecifiers =
+      [&](MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
+          SourceLocation EllipsisLoc) {
         // Parse exception-specification[opt].
         ExceptionSpecificationType ESpecType = EST_None;
         SourceRange ESpecRange;
         SmallVector<ParsedType, 2> DynamicExceptions;
         SmallVector<SourceRange, 2> DynamicExceptionRanges;
         ExprResult NoexceptExpr;
         CachedTokens *ExceptionSpecTokens;
+
+        // At this point we know whether the lambda is mutable so we can
+        // complete the parsing of gnu attributes.
+        for (LateParsedAttribute *Attr : LateParsedAttrs) {
+          ParseLambdaLexedGNUAttributeArgs(*Attr, Attributes, D);
+          delete Attr;
+        }
+        LateParsedAttrs.clear();
+
         ESpecType = tryParseExceptionSpecification(
             /*Delayed=*/false, ESpecRange, DynamicExceptions,
             DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
 
         if (ESpecType != EST_None)
           DeclEndLoc = ESpecRange.getEnd();
 
         // Parse attribute-specifier[opt].
-        if (MaybeParseCXX11Attributes(Attr))
-          DeclEndLoc = Attr.Range.getEnd();
+        if (MaybeParseCXX11Attributes(Attributes))
+          DeclEndLoc = Attributes.Range.getEnd();
 
         // Parse OpenCL addr space attribute.
         if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
                         tok::kw___constant, tok::kw___generic)) {
           ParseOpenCLQualifiers(DS.getAttributes());
           ConsumeToken();
         }
 
auto ParseLambdaSpecifiers =
                 /*RefQualifierIsLvalueRef=*/true,
                 /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType, ESpecRange,
                 DynamicExceptions.data(), DynamicExceptionRanges.data(),
                 DynamicExceptions.size(),
                 NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
                 /*ExceptionSpecTokens*/ nullptr,
                 /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
                 TrailingReturnType, TrailingReturnTypeLoc, &DS),
-            std::move(Attr), DeclEndLoc);
+            std::move(Attributes), DeclEndLoc);
+
+        if (HasParentheses && Tok.is(tok::kw_requires))
+          ParseTrailingRequiresClause(D);
       };
 
-  if (Tok.is(tok::l_paren)) {
-    ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
-                                        Scope::FunctionDeclarationScope |
-                                        Scope::DeclScope);
+  ParseScope Prototype(this, Scope::FunctionPrototypeScope |
 
-    BalancedDelimiterTracker T(*this, tok::l_paren);
-    T.consumeOpen();
-    SourceLocation LParenLoc = T.getOpenLocation();
-
-    // Parse parameter-declaration-clause.
-    SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
-    SourceLocation EllipsisLoc;
 
+  if (Tok.is(tok::l_paren)) {
+    MutableLoc = LambdaLookAheadMutableSpecifier();
+    Actions.ActOnLambdaClosureQualifiers(Intro, MutableLoc);
+
+    BalancedDelimiterTracker T(*this, tok::l_paren);
+    T.consumeOpen();
+    LParenLoc = T.getOpenLocation();
+
     if (Tok.isNot(tok::r_paren)) {
       Actions.RecordParsingTemplateParameterDepth(
           CurTemplateDepthTracker.getOriginalDepth());
 
-      ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
+      ParseParameterDeclarationClause(D.getContext(), Attributes, ParamInfo,
                                       EllipsisLoc);
       // For a generic lambda, each 'auto' within the parameter declaration
       // clause creates a template type parameter, so increment the depth.
       // If we've parsed any explicit template parameters, then the depth will
       // have already been incremented. So we make sure that at most a single
       // depth level is added.
       if (Actions.getCurGenericLambda())
         CurTemplateDepthTracker.setAddedDepth(1);
     }
 
     T.consumeClose();
+    DeclEndLoc = RParenLoc = T.getCloseLocation();
+    HasParentheses = true;
+  }
 
-    // Parse lambda-specifiers.
-    ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
-                          ParamInfo, EllipsisLoc);
-
-    // Parse requires-clause[opt].
-    if (Tok.is(tok::kw_requires))
-      ParseTrailingRequiresClause(D);
-  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
-                         tok::kw_constexpr, tok::kw_consteval,
-                         tok::kw___private, tok::kw___global, tok::kw___local,
-                         tok::kw___constant, tok::kw___generic,
-                         tok::kw_requires, tok::kw_noexcept) ||
-             (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
-    if (!getLangOpts().CPlusPlus2b)
+  // MSVC doesn't support [] __declspec(...) {}, so we do not check for it here.
+  if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
+                  tok::kw_constexpr, tok::kw_consteval, tok::kw___private,
+                  tok::kw___global, tok::kw___local, tok::kw___constant,
+                  tok::kw___generic, tok::kw_requires, tok::kw_noexcept) ||
+    HasSpecifiers = true;
+    if (!HasParentheses && !getLangOpts().CPlusPlus2b) {
       // It's common to forget that one needs '()' before 'mutable', an
       // attribute specifier, the result type, or the requires clause. Deal with
       // this.
       Diag(Tok, diag::ext_lambda_missing_parens)
           << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
+    }
+  }
 
-    SourceLocation NoLoc;
-    // Parse lambda-specifiers.
-    std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo;
-    ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc,
-                          EmptyParamInfo, /*EllipsisLoc=*/NoLoc);
+  if (HasParentheses || HasSpecifiers) {
+    ParseConstexprAndMutableSpecifiers();
   }
 
+  if (!HasParentheses) {
+    Actions.ActOnLambdaClosureQualifiers(Intro, MutableLoc);
+  }
+  Actions.ActOnLambdaClosureParameters(getCurScope(), ParamInfo);
+
+  if (HasSpecifiers || HasParentheses || !LateParsedAttrs.empty())
+    ParseLambdaSpecifiers(ParamInfo, EllipsisLoc);
+
   WarnIfHasCUDATargetAttr();
 
+  Prototype.Exit();
+
   // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
   // it.
   unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
                         Scope::CompoundStmtScope;
   ParseScope BodyScope(this, ScopeFlags);
 
-  Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
+  Actions.ActOnStartOfLambdaDefinition(Intro, D, DS);
 
   // Parse compound-statement.
   if (!Tok.is(tok::l_brace)) {
     Diag(Tok, diag::err_expected_lambda_body);
     Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
     return ExprError();
   }
 
   StmtResult Stmt(ParseCompoundStatementBody());
   BodyScope.Exit();
   TemplateParamScope.Exit();
+  LambdaScope.Exit();
 
   if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
     return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
 
   Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
   return ExprError();
 }
 

clang/lib/Sema/Scope.cpp

if (Flags & (ClassScope | FnScope)) {
     MSLastManglingParent = this;
     MSCurManglingNumber = 1;
   }
   if (flags & BreakScope)         BreakParent = this;
   if (flags & ContinueScope)      ContinueParent = this;
   if (flags & BlockScope)         BlockParent = this;
   if (flags & TemplateParamScope) TemplateParamParent = this;
 
-  // If this is a prototype scope, record that.
-  if (flags & FunctionPrototypeScope) PrototypeDepth++;
+  // If this is a prototype scope, record that. Lambdas have an extra prototype
+  // scope that doesn't add any depth.
+  if (flags & FunctionPrototypeScope && !(flags & LambdaScope))
+    PrototypeDepth++;
 
   if (flags & DeclScope) {
     if (flags & FunctionPrototypeScope)
       ; // Prototype scopes are uninteresting.
     else if ((flags & ClassScope) && getParent()->isClassScope())
       ; // Nested class scopes aren't ambiguous.
     else if ((flags & ClassScope) && getParent()->getFlags() == DeclScope)
       ; // Classes inside of namespaces aren't ambiguous.

clang/lib/Sema/Sema.cpp

for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
     return FunctionScopes[e];
   }
   return nullptr;
 }
 
 LambdaScopeInfo *Sema::getEnclosingLambda() const {
   for (auto *Scope : llvm::reverse(FunctionScopes)) {
     if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
-      if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
+      if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext) &&
+          LSI->AfterParameterList) {
         // We have switched contexts due to template instantiation.
         // FIXME: We should swap out the FunctionScopes during code synthesis
         // so that we don't need to check for this.
         assert(!CodeSynthesisContexts.empty());
         return nullptr;
       }
       return LSI;
     }
LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
   if (IgnoreNonLambdaCapturingScope) {
     auto E = FunctionScopes.rend();
     while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
       ++I;
     if (I == E)
       return nullptr;
   }
   auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
-  if (CurLSI && CurLSI->Lambda &&
-      !CurLSI->Lambda->Encloses(CurContext)) {
+  if (CurLSI && CurLSI->Lambda && CurLSI->CallOperator &&
+      !CurLSI->Lambda->Encloses(CurContext) && CurLSI->AfterParameterList) {
     // We have switched contexts due to template instantiation.
     assert(!CodeSynthesisContexts.empty());
     return nullptr;
   }
 
   return CurLSI;
 }
 

clang/lib/Sema/SemaCXXScopeSpec.cpp

bool Sema::ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc,
                                         CXXScopeSpec &SS) {
   SS.MakeGlobal(Context, CCLoc);
   return false;
 }
 
 bool Sema::ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
                                     SourceLocation ColonColonLoc,
                                     CXXScopeSpec &SS) {
+  if (getCurLambda()) {
+    Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
+    return true;
+  }
+
   CXXRecordDecl *RD = nullptr;
   for (Scope *S = getCurScope(); S; S = S->getParent()) {
     if (S->isFunctionScope()) {
       if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(S->getEntity()))
         RD = MD->getParent();
       break;
     }
     if (S->isClassScope()) {
       RD = cast<CXXRecordDecl>(S->getEntity());
       break;
     }
   }
 
   if (!RD) {
     Diag(SuperLoc, diag::err_invalid_super_scope);
     return true;
-  } else if (RD->isLambda()) {
-    Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
-    return true;
   } else if (RD->getNumBases() == 0) {
     Diag(SuperLoc, diag::err_no_base_classes) << RD->getName();
     return true;
   }
 
   SS.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
   return false;
 }

clang/lib/Sema/SemaExpr.cpp

#include "clang/AST/DeclNodes.inc"
 
   case Decl::Binding: {
     // These are always lvalues.
     valueKind = VK_LValue;
     type = type.getNonReferenceType();
     // FIXME: Support lambda-capture of BindingDecls, once CWG actually
     // decides how that's supposed to work.
     auto *BD = cast<BindingDecl>(VD);
-    if (BD->getDeclContext() != CurContext) {
+    if (BD->getDeclContext() != CurContext && !isUnevaluatedContext()) {
       auto *DD = dyn_cast_or_null<VarDecl>(BD->getDecomposedDecl());
       if (DD && DD->hasLocalStorage())
         diagnoseUncapturableValueReference(*this, Loc, BD);
     }
     break;
   }
 
   case Decl::Function: {
if (llvm::none_of(LSI->Captures, [](Capture &C) {
       })) {
     FixBuffer.assign({"&", Separator});
     Sema.Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
         << /*reference*/ 1
         << FixItHint::CreateInsertion(DefaultInsertLoc, FixBuffer);
   }
 }
 
+static bool CheckCaptureUseBeforeLambdaQualifiers(Sema &S, VarDecl *Var,
+                                                  SourceLocation ExprLoc,
+                                                  LambdaScopeInfo *LSI) {
+  if (Var->isInvalidDecl())
+    return false;
+
+  bool ByCopy = LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByval;
+  SourceLocation Loc = LSI->IntroducerRange.getBegin();
+  bool Explicitly = false;
+  for (auto &&C : LSI->DelayedCaptures) {
+    VarDecl *CV = C.second.Var;
+    if (Var != CV)
+      continue;
+    ByCopy = C.second.Kind == LambdaCaptureKind::LCK_ByCopy;
+    Loc = C.second.Loc;
+    Explicitly = true;
+    break;
+  }
+  if (ByCopy && !LSI->HasKnownMutability) {
+    // This can only occur in a non-ODR context, so we need to diagnose eagerly,
+    // even when BuildAndDiagnose is false
+    S.Diag(ExprLoc, diag::err_lambda_used_before_capture) << Var;
+    S.Diag(Loc, diag::note_var_explicitly_captured_here) << Var << Explicitly;
+    if (!Var->isInitCapture())
+      S.Diag(Var->getBeginLoc(), diag::note_entity_declared_at) << Var;
+    Var->setInvalidDecl();
+    return false;
+  }
+  return true;
+}
+
 bool Sema::tryCaptureVariable(
     VarDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
     SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType,
     QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt) {
+
   // An init-capture is notionally from the context surrounding its
   // declaration, but its parent DC is the lambda class.
   DeclContext *VarDC = Var->getDeclContext();
   if (Var->isInitCapture())
     VarDC = VarDC->getParent();
 
   DeclContext *DC = CurContext;
   const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
       ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
   // We need to sync up the Declaration Context with the
   // FunctionScopeIndexToStopAt
   if (FunctionScopeIndexToStopAt) {
     unsigned FSIndex = FunctionScopes.size() - 1;
     while (FSIndex != MaxFunctionScopesIndex) {
       DC = getLambdaAwareParentOfDeclContext(DC);
       --FSIndex;
     }
   }
 
-
-  // If the variable is declared in the current context, there is no need to
-  // capture it.
-  if (VarDC == DC) return true;
-
   // Capture global variables if it is required to use private copy of this
   // variable.
   bool IsGlobal = !Var->hasLocalStorage();
   if (IsGlobal &&
       !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
                                                 MaxFunctionScopesIndex)))
     return true;
   Var = Var->getCanonicalDecl();
 
   // Walk up the stack to determine whether we can capture the variable,
   // performing the "simple" checks that don't depend on type. We stop when
   // we've either hit the declared scope of the variable or find an existing
   // capture of that variable.  We start from the innermost capturing-entity
   // (the DC) and ensure that all intervening capturing-entities
   // (blocks/lambdas etc.) between the innermost capturer and the variable`s
   // declcontext can either capture the variable or have already captured
   // the variable.
   CaptureType = Var->getType();
   DeclRefType = CaptureType.getNonReferenceType();
   bool Nested = false;
   bool Explicit = (Kind != TryCapture_Implicit);
   unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
+  bool IsInScopeDeclarationContext;
+  bool CanCapture;
   do {
+    IsInScopeDeclarationContext = true;
+    CanCapture = true;
+
+    LambdaScopeInfo *LSI = nullptr;
+    if (!FunctionScopes.empty())
+      LSI = dyn_cast_or_null<LambdaScopeInfo>(
+          FunctionScopes[FunctionScopesIndex]);
+
+    IsInScopeDeclarationContext =
+        !LSI || LSI->AfterParameterList || CurContext == LSI->CallOperator;
+
+    if (LSI && !LSI->AfterParameterList) {
+      // This allows capturing parameters from a default value which does not
+      // seems correct
+      if (isa<ParmVarDecl>(Var) && !Var->getDeclContext()->isFunctionOrMethod())
+        return true;
+    }
+    if (LSI && !LSI->HasKnownMutability) {
+      if (!CheckCaptureUseBeforeLambdaQualifiers(*this, Var, ExprLoc, LSI)) {
+        break;
+      }
+      CanCapture = false;
+    }
+    // If the variable is declared in the current context, there is no need to
+    // capture it.
+    if (IsInScopeDeclarationContext &&
+        FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
+      return true;
+
     // Only block literals, captured statements, and lambda expressions can
     // capture; other scopes don't work.
-    DeclContext *ParentDC = getParentOfCapturingContextOrNull(DC, Var,
-                                                              ExprLoc,
-                                                              BuildAndDiagnose,
-                                                              *this);
+    DeclContext *ParentDC =
+        !IsInScopeDeclarationContext
+            ? DC->getParent()
+            : getParentOfCapturingContextOrNull(DC, Var, ExprLoc,
+                                                BuildAndDiagnose, *this);
     // We need to check for the parent *first* because, if we *have*
     // private-captured a global variable, we need to recursively capture it in
     // intermediate blocks, lambdas, etc.
     if (!ParentDC) {
       if (IsGlobal) {
         FunctionScopesIndex = MaxFunctionScopesIndex - 1;
         break;
       }
       return true;
     }
 
     FunctionScopeInfo  *FSI = FunctionScopes[FunctionScopesIndex];
     CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
 
-
     // Check whether we've already captured it.
-    if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType,
-                                             DeclRefType)) {
+    if (CanCapture && isVariableAlreadyCapturedInScopeInfo(
+                          CSI, Var, Nested, CaptureType, DeclRefType)) {
       CSI->getCapture(Var).markUsed(BuildAndDiagnose);
       break;
     }
     // If we are instantiating a generic lambda call operator body,
     // we do not want to capture new variables.  What was captured
     // during either a lambdas transformation or initial parsing
     // should be used.
-    if (isGenericLambdaCallOperatorSpecialization(DC)) {
+    if (CanCapture && isGenericLambdaCallOperatorSpecialization(DC)) {
       if (BuildAndDiagnose) {
         LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
         if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None) {
           Diag(ExprLoc, diag::err_lambda_impcap) << Var;
           Diag(Var->getLocation(), diag::note_previous_decl) << Var;
           Diag(LSI->Lambda->getBeginLoc(), diag::note_lambda_decl);
           buildLambdaCaptureFixit(*this, LSI, Var);
         } else
           diagnoseUncapturableValueReference(*this, ExprLoc, Var);
       }
       return true;
     }
 
     // Try to capture variable-length arrays types.
-    if (Var->getType()->isVariablyModifiedType()) {
+    if (CanCapture && Var->getType()->isVariablyModifiedType()) {
       // We're going to walk down into the type and look for VLA
       // expressions.
       QualType QTy = Var->getType();
       if (ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
         QTy = PVD->getOriginalType();
       captureVariablyModifiedType(Context, QTy, CSI);
     }
 
-    if (getLangOpts().OpenMP) {
+    if (CanCapture && getLangOpts().OpenMP) {
       if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
         // OpenMP private variables should not be captured in outer scope, so
         // just break here. Similarly, global variables that are captured in a
         // target region should not be captured outside the scope of the region.
         if (RSI->CapRegionKind == CR_OpenMP) {
           OpenMPClauseKind IsOpenMPPrivateDecl = isOpenMPPrivateDecl(
               Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
           // If the variable is private (i.e. not captured) and has variably
if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
         // explicitly.  Suggestion:
         //  - create const bool VariableCaptureWasInitiallyExplicit = Explicit
         //    at the function head
         //  - cache the StartingDeclContext - this must be a lambda
         //  - captureInLambda in the innermost lambda the variable.
       }
       return true;
     }
-
+    Explicit = false;
     FunctionScopesIndex--;
+    if (IsInScopeDeclarationContext)
       DC = ParentDC;
-    Explicit = false;
   } while (!VarDC->Equals(DC));
 
   // Walk back down the scope stack, (e.g. from outer lambda to inner lambda)
   // computing the type of the capture at each step, checking type-specific
   // requirements, and adding captures if requested.
   // If the variable had already been captured previously, we start capturing
   // at the lambda nested within that one.
   bool Invalid = false;
if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
       Nested = true;
     } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
       Invalid = !captureInCapturedRegion(
           RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
           Kind, /*IsTopScope*/ I == N - 1, *this, Invalid);
       Nested = true;
     } else {
       LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
+      if (!CheckCaptureUseBeforeLambdaQualifiers(*this, Var, ExprLoc, LSI)) {
+        return true;
+      }
       Invalid =
           !captureInLambda(LSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
                            DeclRefType, Nested, Kind, EllipsisLoc,
                            /*IsTopScope*/ I == N - 1, *this, Invalid);
       Nested = true;
     }
 
     if (Invalid && !BuildAndDiagnose)

clang/lib/Sema/SemaExprCXX.cpp

for (int I = FunctionScopes.size();
 
     if (!CurLSI->isCXXThisCaptured())
         continue;
 
     auto C = CurLSI->getCXXThisCapture();
 
     if (C.isCopyCapture()) {
       ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
-      if (CurLSI->CallOperator->isConst())
+      if (!CurLSI->Mutable)
         ClassType.addConst();
       return ASTCtx.getPointerType(ClassType);
     }
   }
 
   // 2) We've run out of ScopeInfos but check 1. if CurDC is a lambda (which
   //    can happen during instantiation of its nested generic lambda call
   //    operator); 2. if we're in a lambda scope (lambda body).

clang/lib/Sema/SemaLambda.cpp

 
 CXXRecordDecl *
 Sema::createLambdaClosureType(SourceRange IntroducerRange, TypeSourceInfo *Info,
                               unsigned LambdaDependencyKind,
                               LambdaCaptureDefault CaptureDefault) {
   DeclContext *DC = CurContext;
   while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext()))
     DC = DC->getParent();
-  bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(),
-                                                               *this);
+
+  bool IsGenericLambda =
+      Info && getGenericLambdaTemplateParameterList(getCurLambda(), *this);
   // Start constructing the lambda class.
   CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(
       Context, DC, Info, IntroducerRange.getBegin(), LambdaDependencyKind,
       IsGenericLambda, CaptureDefault);
   DC->addDecl(Class);
 
   return Class;
 }
return std::make_tuple(
         &Context.getManglingNumberContext(ASTContext::NeedExtraManglingDecl,
                                           ManglingContextDecl),
         ManglingContextDecl);
   }
 
   llvm_unreachable("unexpected context");
 }
 
-CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
-                                           SourceRange IntroducerRange,
-                                           TypeSourceInfo *MethodTypeInfo,
-                                           SourceLocation EndLoc,
-                                           ArrayRef<ParmVarDecl *> Params,
-                                           ConstexprSpecKind ConstexprKind,
-                                           Expr *TrailingRequiresClause) {
+static QualType
+buildTypeForLambdaCallOperator(Sema &S, clang::CXXRecordDecl *Class,
+                               TemplateParameterList *TemplateParams,
+                               TypeSourceInfo *MethodTypeInfo) {
+  assert(MethodTypeInfo && "expected a non null type");
+
   QualType MethodType = MethodTypeInfo->getType();
-  TemplateParameterList *TemplateParams =
-      getGenericLambdaTemplateParameterList(getCurLambda(), *this);
   // If a lambda appears in a dependent context or is a generic lambda (has
   // template parameters) and has an 'auto' return type, deduce it to a
   // dependent type.
   if (Class->isDependentContext() || TemplateParams) {
     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
     QualType Result = FPT->getReturnType();
     if (Result->isUndeducedType()) {
-      Result = SubstAutoTypeDependent(Result);
-      MethodType = Context.getFunctionType(Result, FPT->getParamTypes(),
+      Result = S.SubstAutoTypeDependent(Result);
+      MethodType = S.Context.getFunctionType(Result, FPT->getParamTypes(),
                                              FPT->getExtProtoInfo());
     }
   }
-
-  // C++11 [expr.prim.lambda]p5:
-  //   The closure type for a lambda-expression has a public inline function
-  //   call operator (13.5.4) whose parameters and return type are described by
-  //   the lambda-expression's parameter-declaration-clause and
-  //   trailing-return-type respectively.
-  DeclarationName MethodName
-    = Context.DeclarationNames.getCXXOperatorName(OO_Call);
-  DeclarationNameLoc MethodNameLoc =
-      DeclarationNameLoc::makeCXXOperatorNameLoc(IntroducerRange);
-  CXXMethodDecl *Method = CXXMethodDecl::Create(
-      Context, Class, EndLoc,
-      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
-                          MethodNameLoc),
-      MethodType, MethodTypeInfo, SC_None, getCurFPFeatures().isFPConstrained(),
-      /*isInline=*/true, ConstexprKind, EndLoc, TrailingRequiresClause);
-  Method->setAccess(AS_public);
-  if (!TemplateParams)
-    Class->addDecl(Method);
-
-  // Temporarily set the lexical declaration context to the current
-  // context, so that the Scope stack matches the lexical nesting.
-  Method->setLexicalDeclContext(CurContext);
-  // Create a function template if we have a template parameter list
-  FunctionTemplateDecl *const TemplateMethod = TemplateParams ?
-            FunctionTemplateDecl::Create(Context, Class,
-                                         Method->getLocation(), MethodName,
-                                         TemplateParams,
-                                         Method) : nullptr;
-  if (TemplateMethod) {
-    TemplateMethod->setAccess(AS_public);
-    Method->setDescribedFunctionTemplate(TemplateMethod);
-    Class->addDecl(TemplateMethod);
-    TemplateMethod->setLexicalDeclContext(CurContext);
-  }
-
-  // Add parameters.
-  if (!Params.empty()) {
-    Method->setParams(Params);
-    CheckParmsForFunctionDef(Params,
-                             /*CheckParameterNames=*/false);
-
-    for (auto P : Method->parameters())
-      P->setOwningFunction(Method);
-  }
-
-  return Method;
+  return MethodType;
 }
 
 void Sema::handleLambdaNumbering(
     CXXRecordDecl *Class, CXXMethodDecl *Method,
     Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling) {
   if (Mangling) {
     bool HasKnownInternalLinkage;
     unsigned ManglingNumber, DeviceManglingNumber;
void Sema::handleLambdaNumbering(
   if (MCtx) {
     unsigned ManglingNumber = MCtx->getManglingNumber(Method);
     Class->setLambdaMangling(ManglingNumber, ManglingContextDecl,
                              HasKnownInternalLinkage);
     Class->setDeviceLambdaManglingNumber(MCtx->getDeviceManglingNumber(Method));
   }
 }
 
-void Sema::buildLambdaScope(LambdaScopeInfo *LSI,
-                                        CXXMethodDecl *CallOperator,
-                                        SourceRange IntroducerRange,
-                                        LambdaCaptureDefault CaptureDefault,
-                                        SourceLocation CaptureDefaultLoc,
-                                        bool ExplicitParams,
-                                        bool ExplicitResultType,
-                                        bool Mutable) {
+static void buildLambdaScopeReturnType(Sema &S, LambdaScopeInfo *LSI,
+                                       bool ExplicitResultType) {
+  if (ExplicitResultType) {
+    LSI->HasImplicitReturnType = false;
+    LSI->ReturnType = CallOperator->getReturnType();
+    if (!LSI->ReturnType->isDependentType() && !LSI->ReturnType->isVoidType()) {
+      S.RequireCompleteType(CallOperator->getBeginLoc(), LSI->ReturnType,
+                            diag::err_lambda_incomplete_result);
+    }
+  } else {
+    LSI->HasImplicitReturnType = true;
+  }
+}
+
+void Sema::buildLambdaScope(LambdaScopeInfo *LSI, CXXMethodDecl *CallOperator,
+                            bool ExplicitParams, bool Mutable) {
   LSI->CallOperator = CallOperator;
   CXXRecordDecl *LambdaClass = CallOperator->getParent();
   LSI->Lambda = LambdaClass;
   if (CaptureDefault == LCD_ByCopy)
     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
   else if (CaptureDefault == LCD_ByRef)
     LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
   LSI->CaptureDefaultLoc = CaptureDefaultLoc;
   LSI->IntroducerRange = IntroducerRange;
   LSI->ExplicitParams = ExplicitParams;
   LSI->Mutable = Mutable;
-
-  if (ExplicitResultType) {
-    LSI->ReturnType = CallOperator->getReturnType();
-
-    if (!LSI->ReturnType->isDependentType() &&
-        !LSI->ReturnType->isVoidType()) {
-      if (RequireCompleteType(CallOperator->getBeginLoc(), LSI->ReturnType,
-                              diag::err_lambda_incomplete_result)) {
-        // Do nothing.
-      }
-    }
-  } else {
-    LSI->HasImplicitReturnType = true;
-  }
 }
 
 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) {
   LSI->finishedExplicitCaptures();
 }
 
-void Sema::ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
-                                                    ArrayRef<NamedDecl *> TParams,
-                                                    SourceLocation RAngleLoc,
-                                                    ExprResult RequiresClause) {
+void Sema::ActOnLambdaExplicitTemplateParameterList(
+    LambdaIntroducer &Intro, SourceLocation LAngleLoc,
+    ArrayRef<NamedDecl *> TParams, SourceLocation RAngleLoc,
   LambdaScopeInfo *LSI = getCurLambda();
   assert(LSI && "Expected a lambda scope");
   assert(LSI->NumExplicitTemplateParams == 0 &&
          "Already acted on explicit template parameters");
   assert(LSI->TemplateParams.empty() &&
          "Explicit template parameters should come "
          "before invented (auto) ones");
   assert(!TParams.empty() &&
          "No template parameters to act on");
   LSI->TemplateParams.append(TParams.begin(), TParams.end());
   LSI->NumExplicitTemplateParams = TParams.size();
   LSI->ExplicitTemplateParamsRange = {LAngleLoc, RAngleLoc};
   LSI->RequiresClause = RequiresClause;
 }
 
-void Sema::addLambdaParameters(
-    ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
-    CXXMethodDecl *CallOperator, Scope *CurScope) {
-  // Introduce our parameters into the function scope
-  for (unsigned p = 0, NumParams = CallOperator->getNumParams();
-       p < NumParams; ++p) {
-    ParmVarDecl *Param = CallOperator->getParamDecl(p);
-
-    // If this has an identifier, add it to the scope stack.
-    if (CurScope && Param->getIdentifier()) {
-      bool Error = false;
-      // Resolution of CWG 2211 in C++17 renders shadowing ill-formed, but we
-      // retroactively apply it.
-      for (const auto &Capture : Captures) {
-        if (Capture.Id == Param->getIdentifier()) {
-          Error = true;
-          Diag(Param->getLocation(), diag::err_parameter_shadow_capture);
-          Diag(Capture.Loc, diag::note_var_explicitly_captured_here)
-              << Capture.Id << true;
-        }
-      }
-      if (!Error)
-        CheckShadow(CurScope, Param);
-
-      PushOnScopeChains(Param, CurScope);
-    }
-  }
-}
-
 /// If this expression is an enumerator-like expression of some type
 /// T, return the type T; otherwise, return null.
 ///
 /// Pointer comparisons on the result here should always work because
 /// it's derived from either the parent of an EnumConstantDecl
 /// (i.e. the definition) or the declaration returned by
 /// EnumType::getDecl() (i.e. the definition).
 static EnumDecl *findEnumForBlockReturn(Expr *E) {
QualType Sema::buildLambdaInitCaptureInitialization(
 
   if (Result.isInvalid())
     return QualType();
 
   Init = Result.getAs<Expr>();
   return DeducedType;
 }
 
-VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
-                                              QualType InitCaptureType,
-                                              SourceLocation EllipsisLoc,
-                                              IdentifierInfo *Id,
-                                              unsigned InitStyle, Expr *Init) {
+VarDecl *Sema::createLambdaInitCaptureVarDecl(
+    SourceLocation Loc, QualType InitCaptureType, SourceLocation EllipsisLoc,
+    IdentifierInfo *Id, unsigned InitStyle, Expr *Init, DeclContext *DeclCtx) {
   // FIXME: Retain the TypeSourceInfo from buildLambdaInitCaptureInitialization
   // rather than reconstructing it here.
   TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType, Loc);
   if (auto PETL = TSI->getTypeLoc().getAs<PackExpansionTypeLoc>())
     PETL.setEllipsisLoc(EllipsisLoc);
 
   // Create a dummy variable representing the init-capture. This is not actually
   // used as a variable, and only exists as a way to name and refer to the
   // init-capture.
   // FIXME: Pass in separate source locations for '&' and identifier.
-  VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,
-                                   Loc, Id, InitCaptureType, TSI, SC_Auto);
+  VarDecl *NewVD = VarDecl::Create(Context, DeclCtx, Loc, Loc, Id,
+                                   InitCaptureType, TSI, SC_Auto);
   NewVD->setInitCapture(true);
   NewVD->setReferenced(true);
   // FIXME: Pass in a VarDecl::InitializationStyle.
   NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));
   NewVD->markUsed(Context);
   NewVD->setInit(Init);
   if (NewVD->isParameterPack())
     getCurLambda()->LocalPacks.push_back(NewVD);
   return NewVD;
 }
 
 void Sema::addInitCapture(LambdaScopeInfo *LSI, VarDecl *Var) {
   assert(Var->isInitCapture() && "init capture flag should be set");
   LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(),
                   /*isNested*/false, Var->getLocation(), SourceLocation(),
                   Var->getType(), /*Invalid*/false);
 }
 
-void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
-                                        Declarator &ParamInfo,
-                                        Scope *CurScope) {
-  LambdaScopeInfo *const LSI = getCurLambda();
-  assert(LSI && "LambdaScopeInfo should be on stack!");
-
-  // Determine if we're within a context where we know that the lambda will
-  // be dependent, because there are template parameters in scope.
-  CXXRecordDecl::LambdaDependencyKind LambdaDependencyKind =
-      CXXRecordDecl::LDK_Unknown;
-  if (LSI->NumExplicitTemplateParams > 0) {
-    auto *TemplateParamScope = CurScope->getTemplateParamParent();
-    assert(TemplateParamScope &&
-           "Lambda with explicit template param list should establish a "
-           "template param scope");
-    assert(TemplateParamScope->getParent());
-    if (TemplateParamScope->getParent()->getTemplateParamParent() != nullptr)
-      LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
-  } else if (CurScope->getTemplateParamParent() != nullptr) {
-    LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
-  }
+// Unlike getCurLambda, getCurrentLambdaScopeUnsafe doesn't
+// check that the current lambda is in a consistent or fully constructed state.
+static LambdaScopeInfo *getCurrentLambdaScopeUnsafe(Sema &S) {
+  assert(!S.FunctionScopes.empty());
+  return cast<LambdaScopeInfo>(S.FunctionScopes[S.FunctionScopes.size() - 1]);
 
-  // Determine the signature of the call operator.
-  TypeSourceInfo *MethodTyInfo;
-  bool ExplicitParams = true;
-  bool ExplicitResultType = true;
-  bool ContainsUnexpandedParameterPack = false;
-  SourceLocation EndLoc;
-  SmallVector<ParmVarDecl *, 8> Params;
-  if (ParamInfo.getNumTypeObjects() == 0) {
-    // C++11 [expr.prim.lambda]p4:
-    //   If a lambda-expression does not include a lambda-declarator, it is as
-    //   if the lambda-declarator were ().
-    FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention(
-        /*IsVariadic=*/false, /*IsCXXMethod=*/true));
-    EPI.HasTrailingReturn = true;
-    EPI.TypeQuals.addConst();
-    LangAS AS = getDefaultCXXMethodAddrSpace();
-    if (AS != LangAS::Default)
-      EPI.TypeQuals.addAddressSpace(AS);
+static TypeSourceInfo *
+getDummyLambdaType(Sema &S, SourceLocation Loc = SourceLocation()) {
+  FunctionProtoType::ExtProtoInfo EPI(S.Context.getDefaultCallingConvention(
+  LangAS AS = S.getDefaultCXXMethodAddrSpace();
 
-    // C++1y [expr.prim.lambda]:
-    //   The lambda return type is 'auto', which is replaced by the
-    //   trailing-return type if provided and/or deduced from 'return'
-    //   statements
-    // We don't do this before C++1y, because we don't support deduced return
-    // types there.
-    QualType DefaultTypeForNoTrailingReturn =
-        getLangOpts().CPlusPlus14 ? Context.getAutoDeductType()
-                                  : Context.DependentTy;
-    QualType MethodTy =
-        Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI);
-    MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy);
-    ExplicitParams = false;
-    ExplicitResultType = false;
-    EndLoc = Intro.Range.getEnd();
+  QualType DefaultTypeForNoTrailingReturn = S.getLangOpts().CPlusPlus14
+                                                ? S.Context.getAutoDeductType()
+                                                : S.Context.DependentTy;
+      S.Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI);
+  return S.Context.getTrivialTypeSourceInfo(MethodTy, Loc);
+}
+
+static TypeSourceInfo *getLambdaType(Sema &S, LambdaIntroducer &Intro,
+                                     Declarator &ParamInfo, Scope *CurScope,
+                                     SourceLocation Loc,
+                                     bool &ExplicitResultType) {
+
+
+  TypeSourceInfo *MethodTyInfo;
+
+  if (ParamInfo.getNumTypeObjects() == 0) {
+    MethodTyInfo = getDummyLambdaType(S, Loc);
   } else {
-    assert(ParamInfo.isFunctionDeclarator() &&
-           "lambda-declarator is a function");
     DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();
-
-    // C++11 [expr.prim.lambda]p5:
-    //   This function call operator is declared const (9.3.1) if and only if
-    //   the lambda-expression's parameter-declaration-clause is not followed
-    //   by mutable. It is neither virtual nor declared volatile. [...]
+    ExplicitResultType = FTI.hasTrailingReturnType();
     if (!FTI.hasMutableQualifier()) {
-      FTI.getOrCreateMethodQualifiers().SetTypeQual(DeclSpec::TQ_const,
-                                                    SourceLocation());
+      FTI.getOrCreateMethodQualifiers().SetTypeQual(DeclSpec::TQ_const, Loc);
     }
 
-    MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope);
+    MethodTyInfo = S.GetTypeForDeclarator(ParamInfo, CurScope);
+
     assert(MethodTyInfo && "no type from lambda-declarator");
-    EndLoc = ParamInfo.getSourceRange().getEnd();
 
-    ExplicitResultType = FTI.hasTrailingReturnType();
+    // Check for unexpanded parameter packs in the method type.
+    if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
+      S.DiagnoseUnexpandedParameterPack(Intro.Range.getBegin(), MethodTyInfo,
+                                        S.UPPC_DeclarationType);
+  }
+  return MethodTyInfo;
+}
+
+CXXMethodDecl *Sema::CreateLambdaCallOperator(SourceRange IntroducerRange,
+                                              CXXRecordDecl *Class) {
 
-    if (FTIHasNonVoidParameters(FTI)) {
-      Params.reserve(FTI.NumParams);
-      for (unsigned i = 0, e = FTI.NumParams; i != e; ++i)
-        Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param));
-    }
+  // C++11 [expr.prim.lambda]p5:
+  //   The closure type for a lambda-expression has a public inline function
+  //   call operator (13.5.4) whose parameters and return type are described
+  //   by the lambda-expression's parameter-declaration-clause and
+  //   trailing-return-type respectively.
+  DeclarationName MethodName =
+      Context.DeclarationNames.getCXXOperatorName(OO_Call);
+  DeclarationNameLoc MethodNameLoc =
+      DeclarationNameLoc::makeCXXOperatorNameLoc(IntroducerRange.getBegin());
+  CXXMethodDecl *Method = CXXMethodDecl::Create(
+      Context, Class, SourceLocation(),
+      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
+                          MethodNameLoc),
+      QualType(), nullptr, SC_None, getCurFPFeatures().isFPConstrained(),
+      /*isInline=*/true, ConstexprSpecKind::Unspecified, SourceLocation(),
+      nullptr);
+  Method->setAccess(AS_public);
+  return Method;
 
-    // Check for unexpanded parameter packs in the method type.
-    if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
-      DiagnoseUnexpandedParameterPack(Intro.Range.getBegin(), MethodTyInfo,
-                                      UPPC_DeclarationType);
+void Sema::CompleteLambdaCallOperator(
+    CXXMethodDecl *Method, SourceLocation LambdaLoc,
+    SourceLocation CallOperatorLoc, Expr *TrailingRequiresClause,
+    TypeSourceInfo *MethodTyInfo, ConstexprSpecKind ConstexprKind,
+    ArrayRef<ParmVarDecl *> Params, bool HasExplicitResultType) {
+
+  LambdaScopeInfo *const LSI = getCurrentLambdaScopeUnsafe(*this);
+
+  if (TrailingRequiresClause)
+    Method->setTrailingRequiresClause(TrailingRequiresClause);
+
+  TemplateParameterList *TemplateParams =
+      getGenericLambdaTemplateParameterList(LSI, *this);
+
+  auto DC = Method->getLexicalDeclContext();
+  Method->setLexicalDeclContext(LSI->Lambda);
+  if (TemplateParams) {
+    FunctionTemplateDecl *const TemplateMethod = FunctionTemplateDecl::Create(
+        Context, LSI->Lambda, Method->getLocation(), Method->getDeclName(),
+        TemplateParams, Method);
+    TemplateMethod->setAccess(AS_public);
+    Method->setDescribedFunctionTemplate(TemplateMethod);
+    LSI->Lambda->addDecl(TemplateMethod);
+    TemplateMethod->setLexicalDeclContext(DC);
+  } else {
+    LSI->Lambda->addDecl(Method);
   }
+  LSI->Lambda->setLambdaIsGeneric(TemplateParams);
+  LSI->Lambda->setLambdaTypeInfo(MethodTyInfo);
 
-  CXXRecordDecl *Class = createLambdaClosureType(
-      Intro.Range, MethodTyInfo, LambdaDependencyKind, Intro.Default);
-  CXXMethodDecl *Method =
-      startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,
-                            ParamInfo.getDeclSpec().getConstexprSpecifier(),
-                            ParamInfo.getTrailingRequiresClause());
-  if (ExplicitParams)
-    CheckCXXDefaultArguments(Method);
+  Method->setLexicalDeclContext(DC);
+  Method->setLocation(LambdaLoc);
+  Method->setInnerLocStart(CallOperatorLoc);
+  Method->setTypeSourceInfo(MethodTyInfo);
+  Method->setType(buildTypeForLambdaCallOperator(*this, LSI->Lambda,
+                                                 TemplateParams, MethodTyInfo));
+  Method->setConstexprKind(ConstexprKind);
+  if (!Params.empty()) {
+    CheckParmsForFunctionDef(Params, /*CheckParameterNames=*/false);
+    Method->setParams(Params);
+    for (auto P : Method->parameters())
+      P->setOwningFunction(Method);
+  }
 
-  // This represents the function body for the lambda function, check if we
-  // have to apply optnone due to a pragma.
-  AddRangeBasedOptnone(Method);
+  buildLambdaScopeReturnType(*this, LSI, Method, HasExplicitResultType);
+}
 
-  // code_seg attribute on lambda apply to the method.
-  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
-    Method->addAttr(A);
+void Sema::ActOnLambdaIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {
 
-  // Attributes on the lambda apply to the method.
-  ProcessDeclAttributes(CurScope, Method, ParamInfo);
+  LambdaScopeInfo *const LSI = getCurLambda();
+  assert(LSI && "LambdaScopeInfo should be on stack!");
 
-  // CUDA lambdas get implicit host and device attributes.
-  if (getLangOpts().CUDA)
-    CUDASetLambdaAttrs(Method);
+  if (Intro.Default == LCD_ByCopy)
+    LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;
+  else if (Intro.Default == LCD_ByRef)
+    LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;
+  LSI->CaptureDefaultLoc = Intro.DefaultLoc;
+  LSI->IntroducerRange = Intro.Range;
+  LSI->HasKnownMutability = false;
+  LSI->AfterParameterList = false;
 
-  // OpenMP lambdas might get assumumption attributes.
-  if (LangOpts.OpenMP)
-    ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Method);
+  assert(LSI->NumExplicitTemplateParams == 0);
 
-  // Number the lambda for linkage purposes if necessary.
-  handleLambdaNumbering(Class, Method);
+  // Determine if we're within a context where we know that the lambda will
+  // be dependent, because there are template parameters in scope.
+  CXXRecordDecl::LambdaDependencyKind LambdaDependencyKind =
+      CXXRecordDecl::LDK_Unknown;
+  if (LSI->NumExplicitTemplateParams > 0) {
+    auto *TemplateParamScope = CurScope->getTemplateParamParent();
+    assert(TemplateParamScope &&
+           "Lambda with explicit template param list should establish a "
+           "template param scope");
+    assert(TemplateParamScope->getParent());
+    if (TemplateParamScope->getParent()->getTemplateParamParent() != nullptr)
+      LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
+  } else if (CurScope->getTemplateParamParent() != nullptr) {
+    LambdaDependencyKind = CXXRecordDecl::LDK_AlwaysDependent;
+  }
 
-  // Introduce the function call operator as the current declaration context.
-  PushDeclContext(CurScope, Method);
+  CXXRecordDecl *Class = createLambdaClosureType(
+      Intro.Range, nullptr, LambdaDependencyKind, Intro.Default);
+  LSI->Lambda = Class;
+
+  // C++11 [expr.prim.lambda]p5:
+  //   The closure type for a lambda-expression has a public inline function
+  //   call operator (13.5.4) whose parameters and return type are described
+  //   by the lambda-expression's parameter-declaration-clause and
+  //   trailing-return-type respectively.
 
-  // Build the lambda scope.
-  buildLambdaScope(LSI, Method, Intro.Range, Intro.Default, Intro.DefaultLoc,
-                   ExplicitParams, ExplicitResultType, !Method->isConst());
+  CXXMethodDecl *Method = CreateLambdaCallOperator(Intro.Range, Class);
+  LSI->CallOperator = Method;
+  Method->setLexicalDeclContext(CurContext);
 
-  // C++11 [expr.prim.lambda]p9:
-  //   A lambda-expression whose smallest enclosing scope is a block scope is a
-  //   local lambda expression; any other lambda expression shall not have a
-  //   capture-default or simple-capture in its lambda-introducer.
-  //
-  // For simple-captures, this is covered by the check below that any named
-  // entity is a variable that can be captured.
-  //
-  // For DR1632, we also allow a capture-default in any context where we can
-  // odr-use 'this' (in particular, in a default initializer for a non-static
-  // data member).
-  if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() &&
-      (getCurrentThisType().isNull() ||
-       CheckCXXThisCapture(SourceLocation(), /*Explicit*/true,
-                           /*BuildAndDiagnose*/false)))
-    Diag(Intro.DefaultLoc, diag::err_capture_default_non_local);
+  PushDeclContext(CurScope, Method);
+
+  bool ContainsUnexpandedParameterPack = false;
 
   // Distinct capture names, for diagnostics.
-  llvm::SmallSet<IdentifierInfo*, 8> CaptureNames;
+  llvm::SmallSet<IdentifierInfo *, 8> CaptureNames;
 
   // Handle explicit captures.
-  SourceLocation PrevCaptureLoc
-    = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc;
+  SourceLocation PrevCaptureLoc =
+      Intro.Default == LCD_None ? Intro.Range.getBegin() : Intro.DefaultLoc;
   for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
        PrevCaptureLoc = C->Loc, ++C) {
     if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
-      if (C->Kind == LCK_StarThis)
-        Diag(C->Loc, !getLangOpts().CPlusPlus17
-                             ? diag::ext_star_this_lambda_capture_cxx17
-                             : diag::warn_cxx14_compat_star_this_lambda_capture);
-
-      // C++11 [expr.prim.lambda]p8:
-      //   An identifier or this shall not appear more than once in a
-      //   lambda-capture.
-      if (LSI->isCXXThisCaptured()) {
-        Diag(C->Loc, diag::err_capture_more_than_once)
-            << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
-            << FixItHint::CreateRemoval(
-                   SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
-        continue;
-      }
-
-      // C++2a [expr.prim.lambda]p8:
-      //  If a lambda-capture includes a capture-default that is =,
-      //  each simple-capture of that lambda-capture shall be of the form
-      //  "&identifier", "this", or "* this". [ Note: The form [&,this] is
-      //  redundant but accepted for compatibility with ISO C++14. --end note ]
-      if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)
-        Diag(C->Loc, !getLangOpts().CPlusPlus20
-                         ? diag::ext_equals_this_lambda_capture_cxx20
-                         : diag::warn_cxx17_compat_equals_this_lambda_capture);
-
-      // C++11 [expr.prim.lambda]p12:
-      //   If this is captured by a local lambda expression, its nearest
-      //   enclosing function shall be a non-static member function.
-      QualType ThisCaptureType = getCurrentThisType();
-      if (ThisCaptureType.isNull()) {
-        Diag(C->Loc, diag::err_this_capture) << true;
-        continue;
-      }
-
-      CheckCXXThisCapture(C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true,
-                          /*FunctionScopeIndexToStopAtPtr*/ nullptr,
-                          C->Kind == LCK_StarThis);
-      if (!LSI->Captures.empty())
-        LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
         continue;
     }
 
     assert(C->Id && "missing identifier for capture");
-
     if (C->Init.isInvalid())
       continue;
 
     VarDecl *Var = nullptr;
     if (C->Init.isUsable()) {
       Diag(C->Loc, getLangOpts().CPlusPlus14
                        ? diag::warn_cxx11_compat_init_capture
                        : diag::ext_init_capture);
 
       // If the initializer expression is usable, but the InitCaptureType
       // is not, then an error has occurred - so ignore the capture for now.
       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
       // FIXME: we should create the init capture variable and mark it invalid
       // in this case.
       if (C->InitCaptureType.get().isNull())
         continue;
 
       if (C->Init.get()->containsUnexpandedParameterPack() &&
           !C->InitCaptureType.get()->getAs<PackExpansionType>())
         DiagnoseUnexpandedParameterPack(C->Init.get(), UPPC_Initializer);
 
       unsigned InitStyle;
       switch (C->InitKind) {
       case LambdaCaptureInitKind::NoInit:
         llvm_unreachable("not an init-capture?");
       case LambdaCaptureInitKind::CopyInit:
         InitStyle = VarDecl::CInit;
         break;
       case LambdaCaptureInitKind::DirectInit:
         InitStyle = VarDecl::CallInit;
         break;
       case LambdaCaptureInitKind::ListInit:
         InitStyle = VarDecl::ListInit;
         break;
       }
       Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(),
                                            C->EllipsisLoc, C->Id, InitStyle,
-                                           C->Init.get());
-      // C++1y [expr.prim.lambda]p11:
-      //   An init-capture behaves as if it declares and explicitly
-      //   captures a variable [...] whose declarative region is the
-      //   lambda-expression's compound-statement
-      if (Var)
-        PushOnScopeChains(Var, CurScope, false);
+                                           C->Init.get(), Method);
+      assert(Var && "createLambdaInitCaptureVarDecl returned a null VarDecl?");
+      CheckShadow(CurrentScope, Var);
+      PushOnScopeChains(Var, CurrentScope, false);
     } else {
       assert(C->InitKind == LambdaCaptureInitKind::NoInit &&
              "init capture has valid but null init?");
 
       // C++11 [expr.prim.lambda]p8:
       //   If a lambda-capture includes a capture-default that is &, the
       //   identifiers in the lambda-capture shall not be preceded by &.
       //   If a lambda-capture includes a capture-default that is =, [...]
if (C->Init.isUsable()) {
           continue;
       }
 
       Var = R.getAsSingle<VarDecl>();
       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
         continue;
     }
 
+    // C++11 [expr.prim.lambda]p10:
+    //   [...] each such lookup shall find a variable with automatic storage
+    //   duration declared in the reaching scope of the local lambda expression.
+    // Note that the 'reaching scope' check happens in tryCaptureVariable().
+    if (!Var) {
+      Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
+      continue;
+    }
+
     // C++11 [expr.prim.lambda]p8:
     //   An identifier or this shall not appear more than once in a
     //   lambda-capture.
     if (!CaptureNames.insert(C->Id).second) {
-      if (Var && LSI->isCaptured(Var)) {
+      auto It = llvm::find_if(LSI->DelayedCaptures, [&Var](auto &&Pair) {
+        return Pair.second.Var == Var;
+      });
+      if (It != LSI->DelayedCaptures.end()) {
         Diag(C->Loc, diag::err_capture_more_than_once)
-            << C->Id << SourceRange(LSI->getCapture(Var).getLocation())
+            << C->Id << SourceRange(It->second.Loc)
             << FixItHint::CreateRemoval(
                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
       } else
         // Previous capture captured something different (one or both was
         // an init-cpature): no fixit.
         Diag(C->Loc, diag::err_capture_more_than_once) << C->Id;
       continue;
     }
 
-    // C++11 [expr.prim.lambda]p10:
-    //   [...] each such lookup shall find a variable with automatic storage
-    //   duration declared in the reaching scope of the local lambda expression.
-    // Note that the 'reaching scope' check happens in tryCaptureVariable().
-    if (!Var) {
-      Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
-      continue;
-    }
-
     // Ignore invalid decls; they'll just confuse the code later.
     if (Var->isInvalidDecl())
       continue;
 
     if (!Var->hasLocalStorage()) {
       Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id;
       Diag(Var->getLocation(), diag::note_previous_decl) << C->Id;
       continue;
if (C->EllipsisLoc.isValid()) {
                                    : SourceRange(C->Loc));
 
         // Just ignore the ellipsis.
       }
     } else if (Var->isParameterPack()) {
       ContainsUnexpandedParameterPack = true;
     }
 
-    if (C->Init.isUsable()) {
-      addInitCapture(LSI, Var);
+    if (Var)
+      LSI->DelayedCaptures[std::distance(Intro.Captures.begin(), C)] =
+          LambdaScopeInfo::DelayedCapture{Var, C->ExplicitRange.getBegin(),
+                                          C->Kind};
+  }
+
+  LSI->ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack;
+  PopDeclContext();
+}
+
+static void AddExplicitCapturesToContext(Sema &S, LambdaScopeInfo *LSI,
+                                         LambdaIntroducer &Intro) {
+  SourceLocation PrevCaptureLoc;
+  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
+       PrevCaptureLoc = C->Loc, ++C) {
+    if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
+      if (C->Kind == LCK_StarThis)
+        S.Diag(C->Loc, !S.getLangOpts().CPlusPlus17
+                           ? diag::ext_star_this_lambda_capture_cxx17
+                           : diag::warn_cxx14_compat_star_this_lambda_capture);
+
+      // C++11 [expr.prim.lambda]p8:
+      //   An identifier or this shall not appear more than once in a
+      //   lambda-capture.
+      if (LSI->isCXXThisCaptured()) {
+        S.Diag(C->Loc, diag::err_capture_more_than_once)
+            << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
+            << FixItHint::CreateRemoval(
+                   SourceRange(S.getLocForEndOfToken(PrevCaptureLoc), C->Loc));
+        continue;
+      }
+
+      // C++20 [expr.prim.lambda]p8:
+      //  If a lambda-capture includes a capture-default that is =,
+      //  each simple-capture of that lambda-capture shall be of the form
+      //  "&identifier", "this", or "* this". [ Note: The form [&,this] is
+      //  redundant but accepted for compatibility with ISO C++14. --end note ]
+      if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)
+        S.Diag(C->Loc,
+               !S.getLangOpts().CPlusPlus20
+                   ? diag::ext_equals_this_lambda_capture_cxx20
+                   : diag::warn_cxx17_compat_equals_this_lambda_capture);
+
+      // C++11 [expr.prim.lambda]p12:
+      //   If this is captured by a local lambda expression, its nearest
+      //   enclosing function shall be a non-static member function.
+      QualType ThisCaptureType = S.getCurrentThisType();
+      if (ThisCaptureType.isNull()) {
+        S.Diag(C->Loc, diag::err_this_capture) << true;
+        continue;
+      }
+      S.CheckCXXThisCapture(C->Loc, true, true, nullptr,
+                            C->Kind == LCK_StarThis);
+    } else {
+      VarDecl *Var =
+          LSI->DelayedCaptures[std::distance(Intro.Captures.begin(), C)].Var;
+      if (!Var)
+        continue;
+      if (Var->isInitCapture() && C->Init.isUsable()) {
+        S.addInitCapture(LSI, Var);
+        S.PushOnScopeChains(Var, S.getCurScope(), false);
       } else {
-      TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef :
-                                                   TryCapture_ExplicitByVal;
-      tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc);
+        Sema::TryCaptureKind Kind = C->Kind == LCK_ByRef
+                                        ? Sema::TryCapture_ExplicitByRef
+                                        : Sema::TryCapture_ExplicitByVal;
+        S.tryCaptureVariable(Var, C->Loc, Kind, C->EllipsisLoc);
+      }
     }
     if (!LSI->Captures.empty())
       LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
   }
-  finishLambdaExplicitCaptures(LSI);
+  S.finishLambdaExplicitCaptures(LSI);
+}
 
-  LSI->ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack;
+void Sema::ActOnLambdaClosureQualifiers(LambdaIntroducer &Intro,
+                                        SourceLocation MutableLoc) {
+
+  LambdaScopeInfo *const LSI = getCurrentLambdaScopeUnsafe(*this);
+  LSI->Mutable = MutableLoc.isValid();
+  LSI->HasKnownMutability = true;
+  ContextRAII Context(*this, LSI->CallOperator, /*NewThisContext*/ false);
+  AddExplicitCapturesToContext(*this, LSI, Intro);
+
+  // C++11 [expr.prim.lambda]p9:
+  //   A lambda-expression whose smallest enclosing scope is a block scope is a
+  //   local lambda expression; any other lambda expression shall not have a
+  //   capture-default or simple-capture in its lambda-introducer.
+  //
+  // For simple-captures, this is covered by the check below that any named
+  // entity is a variable that can be captured.
+  //
+  // For DR1632, we also allow a capture-default in any context where we can
+  // odr-use 'this' (in particular, in a default initializer for a non-static
+  // data member).
+  if (Intro.Default != LCD_None &&
+      !LSI->Lambda->getParent()->isFunctionOrMethod() &&
+      (getCurrentThisType().isNull() ||
+       CheckCXXThisCapture(SourceLocation(), /*Explicit*/ true,
+                           /*BuildAndDiagnose*/ false)))
+    Diag(Intro.DefaultLoc, diag::err_capture_default_non_local);
+
+  for (auto &&C : LSI->DelayedCaptures) {
+    VarDecl *Var = C.second.Var;
+    if (Var && Var->isInitCapture()) {
+      PushOnScopeChains(Var, CurScope, false);
+    }
+  }
+}
+
+void Sema::ActOnLambdaClosureParameters(
+    Scope *LambdaScope, MutableArrayRef<DeclaratorChunk::ParamInfo> Params) {
+  LambdaScopeInfo *const LSI = getCurrentLambdaScopeUnsafe(*this);
+  PushDeclContext(LambdaScope, LSI->CallOperator);
+
+  for (const DeclaratorChunk::ParamInfo &P : Params) {
+    auto *Param = cast<ParmVarDecl>(P.Param);
+    Param->setOwningFunction(LSI->CallOperator);
+    if (Param->getIdentifier())
+      PushOnScopeChains(Param, LambdaScope, false);
+  }
+
+  LSI->AfterParameterList = true;
+}
+
+void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
+                                        Declarator &ParamInfo,
+                                        const DeclSpec &DS) {
+
+  LambdaScopeInfo *const LSI = getCurrentLambdaScopeUnsafe(*this);
+  LSI->CallOperator->setConstexprKind(DS.getConstexprSpecifier());
+
+  SmallVector<ParmVarDecl *, 8> Params;
+  bool ExplicitResultType;
+
+  SourceLocation TypeLoc, CallOperatorLoc;
+  if (ParamInfo.getNumTypeObjects() == 0) {
+    CallOperatorLoc = TypeLoc = Intro.Range.getEnd();
+  } else {
+    unsigned index;
+    ParamInfo.isFunctionDeclarator(index);
+    const auto &Object = ParamInfo.getTypeObject(index);
+    TypeLoc =
+        Object.Loc.isValid() ? Object.Loc : ParamInfo.getSourceRange().getEnd();
+    CallOperatorLoc = ParamInfo.getSourceRange().getEnd();
+  }
+
+  CXXRecordDecl *Class = LSI->Lambda;
+  CXXMethodDecl *Method = LSI->CallOperator;
+
+  TypeSourceInfo *MethodTyInfo = getLambdaType(
+      *this, Intro, ParamInfo, getCurScope(), TypeLoc, ExplicitResultType);
 
-  // Add lambda parameters into scope.
-  addLambdaParameters(Intro.Captures, Method, CurScope);
+  LSI->ExplicitParams = ParamInfo.getNumTypeObjects() != 0;
+
+  if (ParamInfo.isFunctionDeclarator() != 0 &&
+      !FTIHasSingleVoidParameter(ParamInfo.getFunctionTypeInfo())) {
+    const auto &FTI = ParamInfo.getFunctionTypeInfo();
+    Params.reserve(Params.size());
+    for (unsigned I = 0; I < FTI.NumParams; ++I) {
+      auto *Param = cast<ParmVarDecl>(FTI.Params[I].Param);
+      Param->setScopeInfo(0, Params.size());
+      Params.push_back(Param);
+    }
+  }
+
+  CompleteLambdaCallOperator(Method, Intro.Range.getBegin(), CallOperatorLoc,
+                             ParamInfo.getTrailingRequiresClause(),
+                             MethodTyInfo,
+                             ParamInfo.getDeclSpec().getConstexprSpecifier(),
+                             Params, ExplicitResultType);
+
+  ContextRAII ManglingContext(*this, Class->getDeclContext());
+
+  CheckCXXDefaultArguments(Method);
+
+  // This represents the function body for the lambda function, check if we
+  // have to apply optnone due to a pragma.
+  AddRangeBasedOptnone(Method);
+
+  // code_seg attribute on lambda apply to the method.
+  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(
+          Method, /*IsDefinition=*/true))
+    Method->addAttr(A);
+
+  // Attributes on the lambda apply to the method.
+  ProcessDeclAttributes(CurScope, Method, ParamInfo);
+
+  // CUDA lambdas get implicit host and device attributes.
+  if (getLangOpts().CUDA)
+    CUDASetLambdaAttrs(Method);
+
+  // OpenMP lambdas might get assumumption attributes.
+  if (LangOpts.OpenMP)
+    ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Method);
+
+  handleLambdaNumbering(Class, Method);
+
+  ManglingContext.pop();
+
+  for (auto &&C : LSI->DelayedCaptures) {
+    VarDecl *Var = C.second.Var;
+    if (Var && Var->isInitCapture()) {
+      PushOnScopeChains(Var, CurScope, false);
+    }
+  }
+  LSI->DelayedCaptures.clear();
+
+  auto CheckRedefinition = [&](ParmVarDecl *Param) {
+    for (const auto &Capture : Intro.Captures) {
+      if (Capture.Id == Param->getIdentifier()) {
+        Diag(Param->getLocation(), diag::err_parameter_shadow_capture);
+        Diag(Capture.Loc, diag::note_var_explicitly_captured_here)
+            << Capture.Id << true;
+        return false;
+      }
+    }
+    return true;
+  };
+
+  for (ParmVarDecl *P : Params) {
+    if (!P->getIdentifier())
+      continue;
+    if (CheckRedefinition(P))
+      CheckShadow(CurScope, P);
+    PushOnScopeChains(P, CurScope);
+  }
 
   // Enter a new evaluation context to insulate the lambda from any
   // cleanups from the enclosing full-expression.
   PushExpressionEvaluationContext(
       LSI->CallOperator->isConsteval()
           ? ExpressionEvaluationContext::ImmediateFunctionContext
           : ExpressionEvaluationContext::PotentiallyEvaluated);
 }

clang/lib/Sema/TreeTransform.h

for (LambdaExpr::capture_iterator C = E->capture_begin(),
     } else {
       SubstInitCapture(SourceLocation(), None);
     }
   }
 
   LambdaScopeInfo *LSI = getSema().PushLambdaScope();
   Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
 
-  // Transform the template parameters, and add them to the current
-  // instantiation scope. The null case is handled correctly.
-  auto TPL = getDerived().TransformTemplateParameterList(
-      E->getTemplateParameterList());
-  LSI->GLTemplateParameterList = TPL;
-
-  // Transform the type of the original lambda's call operator.
-  // The transformation MUST be done in the CurrentInstantiationScope since
-  // it introduces a mapping of the original to the newly created
-  // transformed parameters.
-  TypeSourceInfo *NewCallOpTSI = nullptr;
-  {
-    TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
-    FunctionProtoTypeLoc OldCallOpFPTL =
-        OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
-
-    TypeLocBuilder NewCallOpTLBuilder;
-    SmallVector<QualType, 4> ExceptionStorage;
-    TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
-    QualType NewCallOpType = TransformFunctionProtoType(
-        NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
-        [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
-          return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
-                                              ExceptionStorage, Changed);
-        });
-    if (NewCallOpType.isNull())
-      return ExprError();
-    NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
-                                                        NewCallOpType);
-  }
-
-  // Transform the trailing requires clause
-  ExprResult NewTrailingRequiresClause;
-  if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
-    // FIXME: Concepts: Substitution into requires clause should only happen
-    //                  when checking satisfaction.
-    NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
-
   // Create the local class that will describe the lambda.
 
   // FIXME: DependencyKind below is wrong when substituting inside a templated
   // context that isn't a DeclContext (such as a variable template), or when
   // substituting an unevaluated lambda inside of a function's parameter's type
   // - as parameter types are not instantiated from within a function's DC. We
   // use isUnevaluatedContext() to distinguish the function parameter case.
   CXXRecordDecl::LambdaDependencyKind DependencyKind =
       CXXRecordDecl::LDK_Unknown;
   if (getSema().isUnevaluatedContext() &&
       (getSema().CurContext->isFileContext() ||
        !getSema().CurContext->getParent()->isDependentContext()))
     DependencyKind = CXXRecordDecl::LDK_NeverDependent;
 
   CXXRecordDecl *OldClass = E->getLambdaClass();
-  CXXRecordDecl *Class =
-      getSema().createLambdaClosureType(E->getIntroducerRange(), NewCallOpTSI,
-                                        DependencyKind, E->getCaptureDefault());
-
+  CXXRecordDecl *Class = getSema().createLambdaClosureType(
+      E->getIntroducerRange(), nullptr, DependencyKind, E->getCaptureDefault());
   getDerived().transformedLocalDecl(OldClass, {Class});
 
   Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling;
   if (getDerived().ReplacingOriginal())
     Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(),
                                OldClass->getLambdaManglingNumber(),
                                OldClass->getDeviceLambdaManglingNumber(),
                                OldClass->getLambdaContextDecl());
 
-  // Build the call operator.
-  CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
-      Class, E->getIntroducerRange(), NewCallOpTSI,
-      E->getCallOperator()->getEndLoc(),
-      NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
-      E->getCallOperator()->getConstexprKind(),
-      NewTrailingRequiresClause.get());
-
-  LSI->CallOperator = NewCallOperator;
-
-  getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
-  getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
+  CXXMethodDecl *NewCallOperator =
+      getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class);
+  NewCallOperator->setLexicalDeclContext(getSema().CurContext);
 
-  // Number the lambda for linkage purposes if necessary.
-  getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);
+  // Enter the scope of the lambda.
+  getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(),
+                             E->getCaptureDefault(), E->getCaptureDefaultLoc(),
+                             E->hasExplicitParameters(), E->isMutable());
 
   // Introduce the context of the call operator.
   Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
                                  /*NewThisContext*/false);
 
-  // Enter the scope of the lambda.
-  getSema().buildLambdaScope(LSI, NewCallOperator,
-                             E->getIntroducerRange(),
-                             E->getCaptureDefault(),
-                             E->getCaptureDefaultLoc(),
-                             E->hasExplicitParameters(),
-                             E->hasExplicitResultType(),
-                             E->isMutable());
-
   bool Invalid = false;
 
   // Transform captures.
   for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                  CEnd = E->capture_end();
        C != CEnd; ++C) {
     // When we hit the first implicit capture, tell Sema that we've finished
     // the list of explicit captures.
if (E->isInitCapture(C)) {
         ExprResult Init = Info.first;
         QualType InitQualType = Info.second;
         if (Init.isInvalid() || InitQualType.isNull()) {
           Invalid = true;
           break;
         }
         VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
             OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
-            OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get());
+            OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(),
+            getSema().CurContext);
         if (!NewVD) {
           Invalid = true;
           break;
         }
         NewVDs.push_back(NewVD);
         getSema().addInitCapture(LSI, NewVD);
       }
 
for (LambdaExpr::capture_iterator C = E->capture_begin(),
     }
 
     // Capture the transformed variable.
     getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
                                  EllipsisLoc);
   }
   getSema().finishLambdaExplicitCaptures(LSI);
 
+  // Transform the template parameters, and add them to the current
+  // instantiation scope. The null case is handled correctly.
+  auto TPL = getDerived().TransformTemplateParameterList(
+      E->getTemplateParameterList());
+  LSI->GLTemplateParameterList = TPL;
+
+  // Transform the type of the original lambda's call operator.
+  // The transformation MUST be done in the CurrentInstantiationScope since
+  // it introduces a mapping of the original to the newly created
+  // transformed parameters.
+  TypeSourceInfo *NewCallOpTSI = nullptr;
+  {
+    TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
+    FunctionProtoTypeLoc OldCallOpFPTL =
+        OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
+
+    TypeLocBuilder NewCallOpTLBuilder;
+    SmallVector<QualType, 4> ExceptionStorage;
+    TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
+    QualType NewCallOpType = TransformFunctionProtoType(
+        NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
+        [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
+          return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
+                                              ExceptionStorage, Changed);
+        });
+    if (NewCallOpType.isNull())
+      return ExprError();
+    NewCallOpTSI =
+        NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType);
+  }
+
+  // Transform the trailing requires clause
+  ExprResult NewTrailingRequiresClause;
+  if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
+    // FIXME: Concepts: Substitution into requires clause should only happen
+    //                  when checking satisfaction.
+    NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
+
+  getSema().CompleteLambdaCallOperator(
+      NewCallOperator, E->getCallOperator()->getLocation(),
+      E->getCallOperator()->getInnerLocStart(), NewTrailingRequiresClause.get(),
+      NewCallOpTSI, E->getCallOperator()->getConstexprKind(),
+      NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
+      E->hasExplicitResultType());
+
+  getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
+  getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
+
+  {
+    // Number the lambda for linkage purposes if necessary.
+    Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext());
+    getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);
+  }
+
   // FIXME: Sema's lambda-building mechanism expects us to push an expression
   // evaluation context even if we're not transforming the function body.
   getSema().PushExpressionEvaluationContext(
       Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 
   // Instantiate the body of the lambda expression.
   StmtResult Body =
       Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp

 // RUN: %clang_cc1 -std=c++1y %s -verify
 
 const char *has_no_member = [x("hello")] {}.x; // expected-error {{no member named 'x'}}
 
 double f;
 auto with_float = [f(1.0f)] {
   using T = decltype(f);
   using T = float;
 };
 auto with_float_2 = [&f(f)] { // ok, refers to outer f
   using T = decltype(f);
   using T = double&;
 };
 
-// Within the lambda-expression's compound-statement,
-// the identifier in the init-capture hides any declaration
-// of the same name in scopes enclosing the lambda-expression.
+// Within the lambda-expression the identifier in the init-capture
+// hides any declaration of the same name in scopes enclosing
+// the lambda-expression.
 void hiding() {
   char c;
   (void) [c("foo")] {
     static_assert(sizeof(c) == sizeof(const char*), "");
   };
-  (void) [c("bar")] () -> decltype(c) { // outer c, not init-capture
-    return "baz"; // expected-error {{cannot initialize}}
+  (void)[c("bar")]()->decltype(c) { // inner c
+    return "baz";
   };
 }
 
 struct ExplicitCopy {
   ExplicitCopy(); // expected-note 2{{not viable}}
   explicit ExplicitCopy(const ExplicitCopy&); // expected-note 2{{not a candidate}}
 };
 auto init_kind_1 = [ec(ExplicitCopy())] {};

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp

X infer_X_return_type_2(X x) {
   return [x](int y) {
     if (y > 0)
       return X();
     else
       return x; // ok even in c++11, per dr1048.
   }(5);
 }
 
-struct Incomplete; // expected-note{{forward declaration of 'Incomplete'}}
+struct Incomplete; // expected-note 2{{forward declaration of 'Incomplete'}}
 void test_result_type(int N) {
   auto l1 = [] () -> Incomplete { }; // expected-error{{incomplete result type 'Incomplete' in lambda expression}}
 
   typedef int vla[N];
   auto l2 = [] () -> vla { }; // expected-error{{function cannot return array type 'vla' (aka 'int[N]')}}
 }
+
+template <typename T>
+void test_result_type_tpl(int N) {
+  auto l1 = []() -> T {}; // expected-error{{incomplete result type 'Incomplete' in lambda expression}}
+  typedef int vla[N];
+  auto l2 = []() -> vla {}; // expected-error{{function cannot return array type 'vla' (aka 'int[N]')}}
+}
+
+void test_result_type_call() {
+  test_result_type_tpl<Incomplete>(10); // expected-note {{requested here}}
+}

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

+// RUN: %clang_cc1 -std=c++2b -verify -fsyntax-only %s
+
+template <typename T, typename U>
+constexpr bool is_same = false;
+
+template <typename T>
+constexpr bool is_same<T, T> = true;
+
+void f() {
+
+  int y;
+
+  static_assert(is_same<const int &,
+                        decltype([x = 1] -> decltype((x)) { return x; }())>);
+
+  static_assert(is_same<int &,
+                        decltype([x = 1] mutable -> decltype((x)) { return x; }())>);
+
+  static_assert(is_same<const int &,
+                        decltype([=] -> decltype((y)) { return y; }())>);
+
+  static_assert(is_same<int &,
+                        decltype([=] mutable -> decltype((y)) { return y; }())>);
+
+  static_assert(is_same<const int &,
+                        decltype([=] -> decltype((y)) { return y; }())>);
+
+  static_assert(is_same<int &,
+                        decltype([=] mutable -> decltype((y)) { return y; }())>);
+
+  auto ref = [&x = y](
+                 decltype([&](decltype(x)) { return 0; }) y) {
+    return x;
+  };
+}
+
+void test_noexcept() {
+
+  int y;
+
+  static_assert(noexcept([x = 1] noexcept(is_same<const int &, decltype((x))>) {}()));
+  static_assert(noexcept([x = 1] mutable noexcept(is_same<int &, decltype((x))>) {}()));
+  static_assert(noexcept([y] noexcept(is_same<const int &, decltype((y))>) {}()));
+  static_assert(noexcept([y] mutable noexcept(is_same<int &, decltype((y))>) {}()));
+  static_assert(noexcept([=] noexcept(is_same<const int &, decltype((y))>) {}()));
+  static_assert(noexcept([=] mutable noexcept(is_same<int &, decltype((y))>) {}()));
+  static_assert(noexcept([&] noexcept(is_same<int &, decltype((y))>) {}()));
+  static_assert(noexcept([&] mutable noexcept(is_same<int &, decltype((y))>) {}()));
+
+  static_assert(noexcept([&] mutable noexcept(!is_same<int &, decltype((y))>) {}())); // expected-error {{static_assert failed due}}
+}
+
+void test_requires() {
+
+  int x;
+
+  [x = 1]() requires is_same<const int &, decltype((x))> {}
+  ();
+  [x = 1]() mutable requires is_same<int &, decltype((x))> {}
+  ();
+  [x]() requires is_same<const int &, decltype((x))> {}
+  ();
+  [x]() mutable requires is_same<int &, decltype((x))> {}
+  ();
+  [=]() requires is_same<const int &, decltype((x))> {}
+  ();
+  [=]() mutable requires is_same<int &, decltype((x))> {}
+  ();
+  [&]() requires is_same<int &, decltype((x))> {}
+  ();
+  [&]() mutable requires is_same<int &, decltype((x))> {}
+  ();
+  [&x]() requires is_same<int &, decltype((x))> {}
+  ();
+  [&x]() mutable requires is_same<int &, decltype((x))> {}
+  ();
+
+  [x = 1]() requires is_same<int &, decltype((x))> {} (); //expected-error {{no matching function for call to object of type}} \
+                                                           // expected-note {{candidate function not viable}} \
+                                                           // expected-note {{'is_same<int &, decltype((x))>' evaluated to false}}
+  [x = 1]() mutable requires is_same<const int &, decltype((x))> {} (); // expected-error {{no matching function for call to object of type}} \
+                                                                     // expected-note {{candidate function not viable}} \
+                                                                     // expected-note {{'is_same<const int &, decltype((x))>' evaluated to false}}
+}
+
+void err() {
+  int y, z; // expected-note 2{{declared here}}
+
+  (void)[x = 1]<typename T>                         // expected-note {{variable 'x' is explicitly captured here}}
+  requires(is_same<const int &, decltype((x))>) {}; // expected-error {{captured variable 'x' cannot appear here}}
+
+  (void)[x = 1]<typename T = decltype((x))>{}; // expected-note {{variable 'x' is explicitly captured here}} \
+                                                                 // expected-error {{captured variable 'x' cannot appear here}}
+
+  (void)[=]<typename T = decltype((y))>{}; // expected-note {{variable 'y' is captured here}} \
+                                             // expected-error {{captured variable 'y' cannot appear here}}
+
+  (void)[z]<typename T = decltype((z))>{}; // expected-note {{variable 'z' is explicitly captured here}} \
+                                             // expected-error {{captured variable 'z' cannot appear here}}
+}
+
+void gnu_attributes() {
+  int y;
+  (void)[=]() __attribute__((diagnose_if(!is_same<decltype((y)), const int &>, "wrong type", "warning"))){}();
+  (void)[=]() __attribute__((diagnose_if(!is_same<decltype((y)), int &>, "wrong type", "warning"))){}();
+  // expected-warning@-1 {{wrong type}} expected-note@-1{{'diagnose_if' attribute on 'operator()'}}
+
+  (void)[=]() __attribute__((diagnose_if(!is_same<decltype((y)), int &>, "wrong type", "warning"))) mutable {}();
+  (void)[=]() __attribute__((diagnose_if(!is_same<decltype((y)), const int &>, "wrong type", "warning"))) mutable {}();
+  // expected-warning@-1 {{wrong type}} expected-note@-1{{'diagnose_if' attribute on 'operator()'}}
+
+  (void)[x=1]() __attribute__((diagnose_if(!is_same<decltype((x)), const int &>, "wrong type", "warning"))){}();
+  (void)[x=1]() __attribute__((diagnose_if(!is_same<decltype((x)), int &>, "wrong type", "warning"))){}();
+  // expected-warning@-1 {{wrong type}} expected-note@-1{{'diagnose_if' attribute on 'operator()'}}
+
+  (void)[x=1]() __attribute__((diagnose_if(!is_same<decltype((x)), int &>, "wrong type", "warning"))) mutable {}();
+  (void)[x=1]() __attribute__((diagnose_if(!is_same<decltype((x)), const int &>, "wrong type", "warning"))) mutable {}();
+  // expected-warning@-1 {{wrong type}} expected-note@-1{{'diagnose_if' attribute on 'operator()'}}
+}
+
+void nested() {
+  int x, y, z;
+  (void)[&](
+      decltype([&](
+                   decltype([=](
+                                decltype([&](
+                                             decltype([&](decltype(x)) {})) {})) {})) {})){};
+
+  (void)[&](
+      decltype([&](
+                   decltype([&](
+                                decltype([&](
+                                             decltype([&](decltype(y)) {})) {})) {})) {})){};
+
+  (void)[=](
+      decltype([=](
+                   decltype([=](
+                                decltype([=](
+                                             decltype([&]<decltype(z)> {})) {})) {})) {})){};
+}
+
+template <typename T, typename U>
+void dependent(U&& u) {
+  [&]() requires is_same<decltype(u), T> {}();
+}
+
+template <typename T>
+void dependent_init_capture(T x = 0) {
+  [ y = x + 1, x ]() mutable -> decltype(y + x) requires(is_same<decltype((y)), int &> && is_same<decltype((x)), int &>) {
+    return y;
+  }
+  ();
+  [ y = x + 1, x ]() -> decltype(y + x) requires(is_same<decltype((y)), const int &> && is_same<decltype((x)), const int &>) {
+    return y;
+  }
+  ();
+}
+
+template <typename T, typename...>
+struct extract_type {
+  using type = T;
+};
+
+template <typename... T>
+void dependent_variadic_capture(T... x) {
+  [... y = x, x... ](auto...) mutable -> typename extract_type<decltype(y)...>::type requires((is_same<decltype((y)), int &> && ...) && (is_same<decltype((x)), int &> && ...)) {
+    return 0;
+  }
+  (x...);
+  [... y = x, x... ](auto...) -> typename extract_type<decltype(y)...>::type requires((is_same<decltype((y)), const int &> && ...) && (is_same<decltype((x)), const int &> && ...)) {
+    return 0;
+  }
+  (x...);
+}
+
+void test_dependent() {
+  int v   = 0;
+  int & r = v;
+  const int & cr = v;
+  dependent<int&>(v);
+  dependent<int&>(r);
+  dependent<const int&>(cr);
+  dependent_init_capture(0);
+  dependent_variadic_capture(1, 2, 3, 4);
+}
+
+void check_params() {
+  int i = 0;
+  int &j = i;
+  (void)[=](decltype((j)) jp, decltype((i)) ip) {
+    static_assert(is_same<const int&, decltype((j))>);
+    static_assert(is_same<const int &, decltype((i))>);
+    static_assert(is_same<const int &, decltype((jp))>);
+    static_assert(is_same<const int &, decltype((ip))>);
+  };
+
+  (void)[=](decltype((j)) jp, decltype((i)) ip) mutable {
+    static_assert(is_same<int &, decltype((j))>);
+    static_assert(is_same<int &, decltype((i))>);
+    static_assert(is_same<int &, decltype((jp))>);
+    static_assert(is_same<int &, decltype((ip))>);
+    static_assert(is_same<int &, decltype(jp)>);
+    static_assert(is_same<int &, decltype(ip)>);
+  };
+
+  (void)[a = 0](decltype((a)) ap) mutable {
+    static_assert(is_same<int &, decltype((a))>);
+    static_assert(is_same<int, decltype(a)>);
+    static_assert(is_same<int &, decltype(ap)>);
+  };
+  (void)[a = 0](decltype((a)) ap) {
+    static_assert(is_same<const int &, decltype((a))>);
+    static_assert(is_same<int, decltype(a)>);
+    static_assert(is_same<const int&, decltype((ap))>);
+  };
+}
+
+template <typename T>
+void check_params_tpl() {
+  T i = 0;
+  T &j = i;
+  (void)[=](decltype((j)) jp, decltype((i)) ip) {
+    static_assert(is_same<const int&, decltype((j))>);
+    static_assert(is_same<const int &, decltype((i))>);
+    static_assert(is_same<const int &, decltype((jp))>);
+    static_assert(is_same<const int &, decltype((ip))>);
+  };
+
+  (void)[=](decltype((j)) jp, decltype((i)) ip) mutable {
+    static_assert(is_same<int &, decltype((j))>);
+    static_assert(is_same<int &, decltype((i))>);
+    static_assert(is_same<int &, decltype((jp))>);
+    static_assert(is_same<int &, decltype((ip))>);
+    static_assert(is_same<int &, decltype(jp)>);
+    static_assert(is_same<int &, decltype(ip)>);
+  };
+
+  (void)[a = 0](decltype((a)) ap) mutable {
+    static_assert(is_same<int &, decltype((a))>);
+    static_assert(is_same<int, decltype(a)>);
+    static_assert(is_same<int &, decltype(ap)>);
+  };
+  (void)[a = 0](decltype((a)) ap) {
+    static_assert(is_same<const int &, decltype((a))>);
+    static_assert(is_same<int, decltype(a)>);
+    static_assert(is_same<const int&, decltype((ap))>);
+  };
+}

clang/test/SemaCXX/warn-shadow-in-lambdas.cpp

 #else
     int var = 1; // expected-warning {{declaration shadows a local variable}}
 #endif
     { int z = 1; } // expected-warning {{declaration shadows a local variable}}
   };
 #ifdef AVOID
   auto l4 = [var = param] (int param) { ; }; // no warning
 #else
-  auto l4 = [var = param] (int param) { ; }; // expected-warning {{declaration shadows a local variable}}
+  auto l4 = [var = param](int param) { ; }; // expected-warning 2{{declaration shadows a local variable}}
 #endif
 
   // Make sure that inner lambdas work as well.
   auto l5 = [var, l1] { // expected-note {{variable 'l1' is explicitly captured here}}
     auto l1 = [] { // expected-warning {{declaration shadows a local variable}}
 #ifdef AVOID
       int var = 1; // no warning
 #else

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Deducing this</td>
       <td><a href="https://wg21.link/P0847R7">P0847R7</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Change scope of lambda trailing-return-type</td>
       <td><a href="https://wg21.link/P2036R3">P2036R3</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 15</td>
     </tr>
     <tr>
       <td>Multidimensional subscript operator</td>
       <td><a href="https://wg21.link/P2128R6">P2128R6</a></td>
       <td class="unreleased" align="center">Clang 15</td>
     </tr>
     <tr>
       <td>Non-literal variables (and labels and gotos) in constexpr functions</td>