Implement CWG2631

[cor3ntin]

Summary

Implement https://cplusplus.github.io/CWG/issues/2631.html.

Immediate calls in default arguments and defaults members
are not evaluated.

Instead, we evaluate them when constructing a
CXXDefaultArgExpr/BuildCXXDefaultInitExpr.

The immediate calls are executed by doing a
transform on the initializing expression.

Note that lambdas are not considering subexpressions so
we do not need to transform them.

As a result of this patch, unused default member
initializers are not considered odr-used, and
errors about members binding to local variables
in an outer scope only surface at the point
where a constructor is defined.

[cor3ntin]

clang/include/clang/Sema/Sema.h

9665–9667

I added parentheses here to make that clearer!

clang/lib/Sema/SemaExpr.cpp

5922

@shafk

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

11

I added a comment

[cor3ntin]

clang/lib/Sema/SemaExpr.cpp

5922

Oups, nvm

[cor3ntin]

As discussed with Shafik and Aaron, I'm landing that now so there is some buffer to handle unforeseen issues as i won't be available next week and the one after. Further comments are of course welcomed.
If we don't find any issues we can land https://reviews.llvm.org/D120634 in the coming weeks

[cor3ntin]

The bots are unhappy, I'll investigate later https://lab.llvm.org/buildbot/#/builders/139/builds/30564

[cor3ntin]

I pushed a tentative fix for the bot failure,
alas I'm completely unable to reproduce the issue locally, even
though it does not appear to be architecture dependant afaict.

[royjacobson]

In D136554#3907661, @cor3ntin wrote:

I pushed a tentative fix for the bot failure,
alas I'm completely unable to reproduce the issue locally, even
though it does not appear to be architecture dependant afaict.

It seems like those are the Sony CI bots... They default to C++14 (and a slightly different ABI) so if they fail alone usually it means someone didn't add a -std flag to the test.

[cor3ntin]

In D136554#3907761, @royjacobson wrote:

In D136554#3907661, @cor3ntin wrote:

I pushed a tentative fix for the bot failure,
alas I'm completely unable to reproduce the issue locally, even
though it does not appear to be architecture dependant afaict.

It seems like those are the Sony CI bots... They default to C++14 (and a slightly different ABI) so if they fail alone usually it means someone didn't add a -std flag to the test.

Thanks! this is super useful information and I can now reproduce locally,
Investigating ( the test crashes, so it's not just a missing flag )

[cor3ntin]

Make sure cleanup expressions are correctly
added to rewritten initializers (I'm assuming this
did not manifest in C++20 mode because of copy elision)

[cor3ntin]

Cleaner fix:

Only use MaybeCreateExprWithCleanups for member inits.
For default arguments, this is already handled in
ConvertParamDefaultArgument.

[cor3ntin]

clamg-format

[abrachet]

Hi, we're hitting an assertion failure after this patch

llvm-project/clang/lib/Sema/SemaDecl.cpp:15589: Decl *clang::Sema::ActOnFinishFunctionBody(Decl *, Stmt *, bool): Assertion `MaybeODRUseExprs.empty() && "Leftover expressions for odr-use checking"' failed.

Here is a reproducer https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.cpp and https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.sh unfortunately creduce was taking too long before I gave up on it, so sorry it hasn't been reduced at all.

I've verified that with this reverted the problem goes away. Could we revert unless there is a quick fix forward?

[cor3ntin]

In D136554#3909196, @abrachet wrote:

Hi, we're hitting an assertion failure after this patch

llvm-project/clang/lib/Sema/SemaDecl.cpp:15589: Decl *clang::Sema::ActOnFinishFunctionBody(Decl *, Stmt *, bool): Assertion `MaybeODRUseExprs.empty() && "Leftover expressions for odr-use checking"' failed.

Here is a reproducer https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.cpp and https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.sh unfortunately creduce was taking too long before I gave up on it, so sorry it hasn't been reduced at all.

I've verified that with this reverted the problem goes away. Could we revert unless there is a quick fix forward?

Thanks for reporting that. Did you tried a more recent commit? We fixed that issue today. (Along with z couple additional issues)

[abrachet]

In D136554#3909198, @cor3ntin wrote:

In D136554#3909196, @abrachet wrote:

Hi, we're hitting an assertion failure after this patch

llvm-project/clang/lib/Sema/SemaDecl.cpp:15589: Decl *clang::Sema::ActOnFinishFunctionBody(Decl *, Stmt *, bool): Assertion `MaybeODRUseExprs.empty() && "Leftover expressions for odr-use checking"' failed.

Here is a reproducer https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.cpp and https://storage.googleapis.com/fuchsia-artifacts/builds/8798414214460746113/build-debug/clang-crashreports/symbol_server_unittest-48a521.sh unfortunately creduce was taking too long before I gave up on it, so sorry it hasn't been reduced at all.

I've verified that with this reverted the problem goes away. Could we revert unless there is a quick fix forward?

Thanks for reporting that. Did you tried a more recent commit? We fixed that issue today. (Along with z couple additional issues)

Yes, this happens at HEAD (currently ba65584d)

[cor3ntin]

Fascinating. Looking more at the error it seems slightly different than what we fixed this morning.
I'll revert soon when I'm at a computer. Feel free to do it earlier if it's urgent for you
Sorry for the inconvenience.

[cor3ntin]

Reverting now, just re-running the tests to be sure

[cor3ntin]

@abrachet Reverted, sorry again
@aaron.ballman @shafik feel free to investigate the issue, i won't have the opportunity over the next two weeks

[cor3ntin]

Reopening with subsequent changes merged.

[dblaikie]

fwiw, @rsmith came up with a crasher reproducer from this patch here:

template<typename T> struct F {
    template<typename U> F(const U&) {}
};

struct A {
    static constexpr auto x = [] {};
    F<int> f = x;
};

void f(A a = A()) { }

int main() {
    f();
}

This was still failing at52ffc728181bc2d3c889f7f80c252c3433b9e7b6 immediately prior to the revert.

[dblaikie]

Looks like it's distinct from the other reported crash, this one crashes with:

clang-16: /usr/local/google/home/blaikie/dev/llvm/src/clang/lib/CodeGen/CGExpr.cpp:2811: clang::CodeGen::LValue clang::CodeGen::CodeGenFunction::EmitDeclRefLValue(const clang::DeclRefExpr *): Assertion `(ND->isUsed(false) || !isa<VarDecl>(ND) || E->isNonOdrUse() || !E->getLocation().isValid()) && "Should not use decl without marking it used!"' failed.

[cor3ntin]

In D136554#3909488, @dblaikie wrote:

fwiw, @rsmith came up with a crasher reproducer from this patch here:

template<typename T> struct F {
    template<typename U> F(const U&) {}
};

struct A {
    static constexpr auto x = [] {};
    F<int> f = x;
};

void f(A a = A()) { }

int main() {
    f();
}

This was still failing at52ffc728181bc2d3c889f7f80c252c3433b9e7b6 immediately prior to the revert.

This is very helpful, thanks to both Richard and you.
Both issues seem to be related somewhat, there are scenarios in which entities are not marked odr used properly.
The other bug is still reducing, hopefully I'll have a test case for it tomorrow. I don't expect to be able to fix the issue in the next couple of weeks though

[cor3ntin]

reduced to

struct a {
} constexpr b;
class c {
public:
  c(a);
};
class d {
  d() {}
  c e = b;
}

[cor3ntin]

Properly mark default members initializers as ODR-used.

default members initializers were marked as maybe odr-used
but never actually odr-used.

We fix that by checking that an initializer consitutes
a full expression at the point it is used - which will in turn
handle cleanups and odr-use marking properly.

(This needs to be done after MarkDeclarationsReferencedInExpr,
which took me a while to fully figure out)

[aaron.ballman]

The changes generally LGTM, but I'd appreciate a second set of eyes on the changes just to double-check we're implementing the resolution properly.

clang/include/clang/AST/ExprCXX.h

1273

Do we need to update computeDependence() to account for the rewritten Expr *?

clang/include/clang/Sema/Sema.h

1344

It took me a moment to realize this wasn't the end of the structure declaration. :-D

9678–9679

We repeat this pattern four times in this patch; perhaps we should make a helper function for this predicate? Not certain of the best name for it, but removing the duplication might not be a bad idea.

[cor3ntin]

Remove extra ;

clang/include/clang/AST/ExprCXX.h

1273

Looking at the code again, computeDependence do use the rewritten expr if there is one already (contracticting what I previously stated offline)

clang/include/clang/Sema/Sema.h

9678–9679

isNotPotentiallyEvaluatedContext? Something like that

[cor3ntin]

Update DR status

[cor3ntin]

clang/include/clang/Sema/Sema.h

9678–9679

Actually, Maybe we should leave it as is in this patch,
and clean it up as part of https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2564r0.html
IE, I'm not sure i can come up with a completely correct name now.

[aaron.ballman]

LGTM!

clang/include/clang/Sema/Sema.h

9678–9679

That's fine by me; naming is hard.

[cor3ntin]

Thanks Aaron. I hope it sticks this time!

[cor3ntin]

There is still an ODR issue which caused linkers errors
I think I managed to reduce the issue to

template <typename T>
struct function_ref {
    function_ref(auto) {}
};

struct S {
    function_ref<int> X = nullptr;
};

void Do(S = {}) {
}

int main() {
    Do();
}

We mark nullptr odr used but that does not mark function_ref<int>::function_ref() ODR used.
We should make sure that's properly marked once the constructor call is resolved.

[cor3ntin]

• Member initializers wwere not marked odr used properly
• Fixing that unearthed an other bug: consteval calls in a nested member initializers were not properly detected if the member was list initialized to its default value (= {}).

[cor3ntin]

@aaron.ballman if you don't scream, I'll probably try again this week end. I did multiple stage 2 full builds to be sure this time. The fix is pretty small but the investigation took a while...

[aaron.ballman]

The new changes LGTM as well and the bots seem to be happy with things.

[aeubanks]

the following now produces a link error:

$ cat /tmp/a.cc
#include <array>
#include <map>

struct S {
        std::map<int, int> a;
};

using T = std::array<S, 20>;

class C {
        T t{};
};

int main() {
        C c;
}
$ ./build/rel/bin/clang++ -o /dev/null /tmp/a.cc -stdlib=libc++ -fuse-ld=lld
ld.lld: error: undefined hidden symbol: std::__2::map<int, int, std::__2::less<int>, std::__2::allocator<std::__2::pair<int const, int>>>::map[abi:v160000]()
>>> referenced by a.cc
>>>               /tmp/a-042a0e.o:(C::C())
clang: error: linker command failed with exit code 1 (use -v to see invocation)

using a ToT libc++

is this expected?

[cor3ntin]

In D136554#3982161, @aeubanks wrote:

the following now produces a link error:

Thanks for reporting that. It was definitively not expected, I reverted the patch and will have a fix shortly.

[cor3ntin]

Correctly visit array filer when marking
default member init as ODR-used

[aeubanks]

I've bisected another crash to this change. Reverting, and currently creducing a repro.

[aeubanks]

a really bad reduced repro which also has random syntax errors:

using string = struct basic_string {
  constexpr basic_string(char *) {}                 constexpr ~basic_string(
} struct AutocompleteParsingResult struct optional {
  template <typename U = AutocompleteParsingResult> constexpr optional(U &&) {}
  namespace enum { kName } struct AutocompleteParsingResult {
    string StringPiece;
    optional expected_result;
    int max_length = 0
  } kAutocompleteTestcases {
    "", {
      { "", kName }
    }
}

clang -cc1 -x c++ -triple x86_64-unknown-linux-gnu -std=c++20 -fsyntax-only /tmp/reduced.cpp.orig -ferror-limit 1
working on a reduced repro with -ferror-limit=1

[cor3ntin]

Thanks!

Cleaned up version:

struct string {
  constexpr string(const char*) {};
  constexpr ~string();
};
struct AutocompleteParsingResult;
struct optional {
    template <typename U = AutocompleteParsingResult> 
    constexpr optional(U &&) {}
};
struct AutocompleteParsingResult {
    string StringPiece;
    optional expected_result;
    int max_length = 0;
} kAutocompleteTestcases {
    "", {
        { "", 0 }
    }
};

And yes, this is about as reduced as I can make it.
I'll investigate later....

[cor3ntin]

• Make sure cleanups expressions are created in the correct evaluation context. This simplifies and reduce the numbers of nested evaluation contexts we create, notably to make sure the creation of the initialier and cleanup expressions are done in the same context

• Add tests for calls to source location builtin in dependant initializers

[cor3ntin]

@aeubanks I think i got it. Were you having this issue with an open source project by any chance? Maybe i could try it locally before commiting

[aeubanks]

yes, it was chrome
I went ahead and tried the latest patch, it successfully compiles the file that crashed before. I built all of chrome, and now I'm getting one last linker error, I'll try to get some more info about that

[cor3ntin]

In D136554#3986713, @aeubanks wrote:

yes, it was chrome
I went ahead and tried the latest patch, it successfully compiles the file that crashed before. I built all of chrome, and now I'm getting one last linker error, I'll try to get some more info about that

Thanks for confirming :)
If you have the message of that linker error, i might be able to infer a repro from that. Otherwise, I'm going to build chromium

[cor3ntin]

In D136554#3986779, @cor3ntin wrote:

In D136554#3986713, @aeubanks wrote:

yes, it was chrome
I went ahead and tried the latest patch, it successfully compiles the file that crashed before. I built all of chrome, and now I'm getting one last linker error, I'll try to get some more info about that

Thanks for confirming :)
If you have the message of that linker error, i might be able to infer a repro from that. Otherwise, I'm going to build chromium

I got
x86_64-linux-gnu/libnspr4.so: undefined reference to gettid

But otherwise it works fine.
linking with mold fixes the issue.
I can't find an instance of gettid() that would be called from a default parameter or mem initializer list so I would be surprise if it's related. Was that the issue you encountered?

[aeubanks]

no, I got

$ ninja -C out/MyClang/ content_unittests
ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForDefer, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForDefer>>::Receiver(content::mojom::TestInterfaceForDefer*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:90 (../../content/browser/mojo_binder_policy_applier_unittest.cc:90)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForGrant, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForGrant>>::Receiver(content::mojom::TestInterfaceForGrant*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:91 (../../content/browser/mojo_binder_policy_applier_unittest.cc:91)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForCancel, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForCancel>>::Receiver(content::mojom::TestInterfaceForCancel*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:92 (../../content/browser/mojo_binder_policy_applier_unittest.cc:92)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForUnexpected, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForUnexpected>>::Receiver(content::mojom::TestInterfaceForUnexpected*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:93 (../../content/browser/mojo_binder_policy_applier_unittest.cc:93)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

https://crsrc.org/c/content/browser/mojo_binder_policy_applier_unittest.cc;drc=4e1b7bc33d42b401d7d9ad1dcba72883add3e2af;l=90

[cor3ntin]

In D136554#3987122, @aeubanks wrote:

no, I got

$ ninja -C out/MyClang/ content_unittests
ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForDefer, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForDefer>>::Receiver(content::mojom::TestInterfaceForDefer*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:90 (../../content/browser/mojo_binder_policy_applier_unittest.cc:90)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForGrant, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForGrant>>::Receiver(content::mojom::TestInterfaceForGrant*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:91 (../../content/browser/mojo_binder_policy_applier_unittest.cc:91)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForCancel, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForCancel>>::Receiver(content::mojom::TestInterfaceForCancel*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:92 (../../content/browser/mojo_binder_policy_applier_unittest.cc:92)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())

ld.lld: error: undefined symbol: mojo::Receiver<content::mojom::TestInterfaceForUnexpected, mojo::RawPtrImplRefTraits<content::mojom::TestInterfaceForUnexpected>>::Receiver(content::mojom::TestInterfaceForUnexpected*)
>>> referenced by mojo_binder_policy_applier_unittest.cc:93 (../../content/browser/mojo_binder_policy_applier_unittest.cc:93)
>>>               obj/content/test/content_unittests/mojo_binder_policy_applier_unittest.o:(content::TestReceiverCollector::TestReceiverCollector())
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

https://crsrc.org/c/content/browser/mojo_binder_policy_applier_unittest.cc;drc=4e1b7bc33d42b401d7d9ad1dcba72883add3e2af;l=90

Thanks, that was really helpful.
After most of the day spent on compiling clang and reducing, i got it down to

template <typename> 
struct MissingCtr {
  MissingCtr() {}
};
class k {
//public:
  MissingCtr<k> a{};
};
struct b {
  k c{};
};
int main() { b d; }

It would appear to be related to access. I had not yet encountered something access related with this patch!

[cor3ntin]

When a CXXDefaultInitExpr calls a Constructor,
make sure that the fields default initialized by that
constructor are also marked odr used.

[cor3ntin]

@aeubanks I just completed a compilation of all of chrome including tests. let me know if you want to run more tests on your side and thanks again for reporting these issues. I think we are getting there.

[aeubanks]

I'm fine with relanding and seeing if anything else pops up

[dankm]

clang/include/clang/Sema/Sema.h

9697

llvm::None has been deprecated in favour of std::nullopt.

[cor3ntin]

remove llvm::None

[rupprecht]

Looks like the latest reland still has some issue remaining. With asserts enabled, I get: assert.h assertion failed at clang/include/clang/AST/Type.h:752 in const ExtQualsTypeCommonBase *clang::QualType::getCommonPtr() const: !isNull() && "Cannot retrieve a NULL type pointer". I'm going to work on reducing it now.

[cor3ntin]

In D136554#3993791, @rupprecht wrote:

Looks like the latest reland still has some issue remaining. With asserts enabled, I get: assert.h assertion failed at clang/include/clang/AST/Type.h:752 in const ExtQualsTypeCommonBase *clang::QualType::getCommonPtr() const: !isNull() && "Cannot retrieve a NULL type pointer". I'm going to work on reducing it now.

Oh no! I'd love a reduced repro if you can. Or at worse, a stack trace, I'd be happy to investigate. Thanks!

[rupprecht]

Ugh, I left cvise running overnight and forgot to include the validity check by building with a previous clang, so my reduction is invalid. I'm going to run it again, but here's the invalid crasher in the meantime:

struct SourceLocation {
  static SourceLocation current(const char * = __builtin_FILE()) {
    struct Metadata {
      Metadata(SourceLocation = current());
      namespace struct {
        int x = z(x, Metadata())
      } y {
      }

stack trace:

clang: /home/rupprecht/src/llvm-project/clang/include/clang/AST/Type.h:752: const ExtQualsTypeCommonBase *clang::QualType::getCommonPtr() const: Assertion `!isNull() && "Cannot retrieve a NULL type pointer"' failed.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.      Program arguments: bin/clang -c /tmp/repro.cc -std=c++17 -o /tmp/repro.o
1.      <eof> parser at end of file
2.      /tmp/repro.cc:1:1: parsing struct/union/class body 'SourceLocation'
3.      /tmp/repro.cc:2:66: parsing function body 'SourceLocation::current'
4.      /tmp/repro.cc:2:66: in compound statement ('{}')
 #0 0x00005645aaceaaba llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /home/rupprecht/src/llvm-project/llvm/lib/Support/Unix/Signals.inc:567:11
 #1 0x00005645aaceac6b PrintStackTraceSignalHandler(void*) /home/rupprecht/src/llvm-project/llvm/lib/Support/Unix/Signals.inc:641:1
 #2 0x00005645aace92f6 llvm::sys::RunSignalHandlers() /home/rupprecht/src/llvm-project/llvm/lib/Support/Signals.cpp:104:5
 #3 0x00005645aacea3ae llvm::sys::CleanupOnSignal(unsigned long) /home/rupprecht/src/llvm-project/llvm/lib/Support/Unix/Signals.inc:367:1
 #4 0x00005645aac01187 (anonymous namespace)::CrashRecoveryContextImpl::HandleCrash(int, unsigned long) /home/rupprecht/src/llvm-project/llvm/lib/Support/CrashRecoveryContext.cpp:0:7
 #5 0x00005645aac015dc CrashRecoverySignalHandler(int) /home/rupprecht/src/llvm-project/llvm/lib/Support/CrashRecoveryContext.cpp:398:1
 #6 0x00007f34de23daa0 (/lib/x86_64-linux-gnu/libc.so.6+0x3daa0)
 #7 0x00007f34de28957c __pthread_kill_implementation ./nptl/pthread_kill.c:44:76
 #8 0x00007f34de23da02 gsignal ./signal/../sysdeps/posix/raise.c:27:6
 #9 0x00007f34de228469 abort ./stdlib/abort.c:81:7
#10 0x00007f34de228395 _nl_load_domain ./intl/loadmsgcat.c:1177:9
#11 0x00007f34de236ab2 (/lib/x86_64-linux-gnu/libc.so.6+0x36ab2)
#12 0x00005645ab1dae17 clang::QualType::getCommonPtr() const /home/rupprecht/src/llvm-project/clang/include/clang/AST/Type.h:0:5
#13 0x00005645ab1dada5 clang::QualType::getTypePtr() const /home/rupprecht/src/llvm-project/clang/include/clang/AST/Type.h:6622:26
#14 0x00005645ab1da995 clang::QualType::operator->() const /home/rupprecht/src/llvm-project/clang/include/clang/AST/Type.h:794:5
#15 0x00005645b071fe92 clang::computeDependence(clang::CXXThisExpr*) /home/rupprecht/src/llvm-project/clang/lib/AST/ComputeDependence.cpp:312:43
#16 0x00005645aed30c16 clang::CXXThisExpr::CXXThisExpr(clang::SourceLocation, clang::QualType, bool) /home/rupprecht/src/llvm-project/clang/include/clang/AST/ExprCXX.h:1154:19
#17 0x00005645af7f7c53 clang::Sema::BuildCXXThisExpr(clang::SourceLocation, clang::QualType, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaExprCXX.cpp:1400:30
#18 0x00005645af7d46a8 clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::RebuildCXXThisExpr(clang::SourceLocation, clang::QualType, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/TreeTransform.h:3196:22
#19 0x00005645af7b09ae clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformCXXThisExpr(clang::CXXThisExpr*) /home/rupprecht/src/llvm-project/clang/lib/Sema/TreeTransform.h:12139:23
#20 0x00005645af7a9ec5 clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformExpr(clang::Expr*) /home/rupprecht/src/llvm-build/dev/tools/clang/include/clang/AST/StmtNodes.inc:907:1
#21 0x00005645af7b5097 clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformMemberExpr(clang::MemberExpr*) /home/rupprecht/src/llvm-project/clang/lib/Sema/TreeTransform.h:11224:34
#22 0x00005645af7aa857 clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformExpr(clang::Expr*) /home/rupprecht/src/llvm-build/dev/tools/clang/include/clang/AST/StmtNodes.inc:1249:1
#23 0x00005645af7b945a clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformRecoveryExpr(clang::RecoveryExpr*) /home/rupprecht/src/llvm-project/clang/lib/Sema/TreeTransform.h:10929:36
#24 0x00005645af7aade4 clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformExpr(clang::Expr*) /home/rupprecht/src/llvm-build/dev/tools/clang/include/clang/AST/StmtNodes.inc:1431:1
#25 0x00005645af71b9fe clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformInitializer(clang::Expr*, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/TreeTransform.h:4006:25
#26 0x00005645af533e03 clang::Sema::BuildCXXDefaultInitExpr(clang::SourceLocation, clang::FieldDecl*) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaExpr.cpp:6090:19
#27 0x00005645af995bcf (anonymous namespace)::InitListChecker::FillInEmptyInitForField(unsigned int, clang::FieldDecl*, clang::InitializedEntity const&, clang::InitListExpr*, bool&, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaInit.cpp:688:32
#28 0x00005645af98aac1 (anonymous namespace)::InitListChecker::FillInEmptyInitializations(clang::InitializedEntity const&, clang::InitListExpr*, bool&, clang::InitListExpr*, unsigned int, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaInit.cpp:832:9
#29 0x00005645af972d8f (anonymous namespace)::InitListChecker::InitListChecker(clang::Sema&, clang::InitializedEntity const&, clang::InitListExpr*, clang::QualType&, bool, bool, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaInit.cpp:979:28
#30 0x00005645af97ebe3 clang::InitializationSequence::Perform(clang::Sema&, clang::InitializedEntity const&, clang::InitializationKind const&, llvm::MutableArrayRef<clang::Expr*>, clang::QualType*) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaInit.cpp:8555:27
#31 0x00005645af0b1a67 clang::Sema::AddInitializerToDecl(clang::Decl*, clang::Expr*, bool) /home/rupprecht/src/llvm-project/clang/lib/Sema/SemaDecl.cpp:13027:33
#32 0x00005645aec9bb4a clang::Parser::ParseDeclarationAfterDeclaratorAndAttributes(clang::Declarator&, clang::Parser::ParsedTemplateInfo const&, clang::Parser::ForRangeInit*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDecl.cpp:0:15
#33 0x00005645aec99a98 clang::Parser::ParseDeclGroup(clang::ParsingDeclSpec&, clang::DeclaratorContext, clang::ParsedAttributes&, clang::SourceLocation*, clang::Parser::ForRangeInit*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDecl.cpp:2196:9
#34 0x00005645aec98ae1 clang::Parser::ParseSimpleDeclaration(clang::DeclaratorContext, clang::SourceLocation&, clang::ParsedAttributes&, clang::ParsedAttributes&, bool, clang::Parser::ForRangeInit*, clang::SourceLocation*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDecl.cpp:1893:10
#35 0x00005645aec98719 clang::Parser::ParseDeclaration(clang::DeclaratorContext, clang::SourceLocation&, clang::ParsedAttributes&, clang::ParsedAttributes&, clang::SourceLocation*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDecl.cpp:1821:12
#36 0x00005645aec356d9 clang::Parser::ParseStatementOrDeclarationAfterAttributes(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*, clang::ParsedAttributes&, clang::ParsedAttributes&) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseStmt.cpp:247:16
#37 0x00005645aec3503b clang::Parser::ParseStatementOrDeclaration(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseStmt.cpp:115:20
#38 0x00005645aec3dca2 clang::Parser::ParseCompoundStatementBody(bool) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseStmt.cpp:1185:11
#39 0x00005645aec3f3a4 clang::Parser::ParseFunctionStatementBody(clang::Decl*, clang::Parser::ParseScope&) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseStmt.cpp:2449:21
#40 0x00005645aecbb1b9 clang::Parser::ParseLexedMethodDef(clang::Parser::LexedMethod&) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseCXXInlineMethods.cpp:0:3
#41 0x00005645aecbac69 clang::Parser::LexedMethod::ParseLexedMethodDefs() /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseCXXInlineMethods.cpp:275:1
#42 0x00005645aecb9c5a clang::Parser::ParseLexedMethodDefs(clang::Parser::ParsingClass&) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseCXXInlineMethods.cpp:527:33
#43 0x00005645aec6b83f clang::Parser::ParseCXXMemberSpecification(clang::SourceLocation, clang::SourceLocation, clang::ParsedAttributes&, unsigned int, clang::Decl*) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDeclCXX.cpp:3629:5
#44 0x00005645aec69a34 clang::Parser::ParseClassSpecifier(clang::tok::TokenKind, clang::SourceLocation, clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, bool, clang::Parser::DeclSpecContext, clang::ParsedAttributes&) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDeclCXX.cpp:2103:7
#45 0x00005645aeca0586 clang::Parser::ParseDeclarationSpecifiers(clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, clang::Parser::DeclSpecContext, clang::Parser::LateParsedAttrList*, clang::ImplicitTypenameContext) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseDecl.cpp:4225:23
#46 0x00005645aec05f12 clang::Parser::ParseDeclarationSpecifiers(clang::DeclSpec&, clang::Parser::ParsedTemplateInfo const&, clang::AccessSpecifier, clang::Parser::DeclSpecContext, clang::Parser::LateParsedAttrList*) /home/rupprecht/src/llvm-project/clang/include/clang/Parse/Parser.h:2417:5
#47 0x00005645aebff146 clang::Parser::ParseDeclOrFunctionDefInternal(clang::ParsedAttributes&, clang::ParsedAttributes&, clang::ParsingDeclSpec&, clang::AccessSpecifier) /home/rupprecht/src/llvm-project/clang/lib/Parse/Parser.cpp:1120:7
#48 0x00005645aebfec6f clang::Parser::ParseDeclarationOrFunctionDefinition(clang::ParsedAttributes&, clang::ParsedAttributes&, clang::ParsingDeclSpec*, clang::AccessSpecifier) /home/rupprecht/src/llvm-project/clang/lib/Parse/Parser.cpp:1222:12
#49 0x00005645aebfe53f clang::Parser::ParseExternalDeclaration(clang::ParsedAttributes&, clang::ParsedAttributes&, clang::ParsingDeclSpec*) /home/rupprecht/src/llvm-project/clang/lib/Parse/Parser.cpp:1037:14
#50 0x00005645aebfc406 clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, clang::Sema::ModuleImportState&) /home/rupprecht/src/llvm-project/clang/lib/Parse/Parser.cpp:743:12
#51 0x00005645aebfbac0 clang::Parser::ParseFirstTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, clang::Sema::ModuleImportState&) /home/rupprecht/src/llvm-project/clang/lib/Parse/Parser.cpp:591:8
#52 0x00005645aebf6f48 clang::ParseAST(clang::Sema&, bool, bool) /home/rupprecht/src/llvm-project/clang/lib/Parse/ParseAST.cpp:161:15
#53 0x00005645ac094226 clang::ASTFrontendAction::ExecuteAction() /home/rupprecht/src/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1164:1
#54 0x00005645ac270234 clang::CodeGenAction::ExecuteAction() /home/rupprecht/src/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:1170:5
#55 0x00005645ac093c4c clang::FrontendAction::Execute() /home/rupprecht/src/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1059:7
#56 0x00005645abfc5b5c clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /home/rupprecht/src/llvm-project/clang/lib/Frontend/CompilerInstance.cpp:1046:23
#57 0x00005645ac25ad37 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /home/rupprecht/src/llvm-project/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:264:8
#58 0x00005645a741eb00 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /home/rupprecht/src/llvm-project/clang/tools/driver/cc1_main.cpp:251:13
#59 0x00005645a740ca55 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /home/rupprecht/src/llvm-project/clang/tools/driver/driver.cpp:353:5
#60 0x00005645abe88bd5 clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const::$_1::operator()() const /home/rupprecht/src/llvm-project/clang/lib/Driver/Job.cpp:428:34
#61 0x00005645abe88ba5 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const::$_1>(long) /home/rupprecht/src/llvm-project/llvm/include/llvm/ADT/STLFunctionalExtras.h:45:5
#62 0x00005645a992ab49 llvm::function_ref<void ()>::operator()() const /home/rupprecht/src/llvm-project/llvm/include/llvm/ADT/STLFunctionalExtras.h:68:5
#63 0x00005645aac00f9a llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) /home/rupprecht/src/llvm-project/llvm/lib/Support/CrashRecoveryContext.cpp:434:3
#64 0x00005645abe8838b clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const /home/rupprecht/src/llvm-project/clang/lib/Driver/Job.cpp:428:7
#65 0x00005645abe2890f clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const /home/rupprecht/src/llvm-project/clang/lib/Driver/Compilation.cpp:199:15
#66 0x00005645abe28b17 clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&, bool) const /home/rupprecht/src/llvm-project/clang/lib/Driver/Compilation.cpp:253:13
#67 0x00005645abe41d58 clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&) /home/rupprecht/src/llvm-project/clang/lib/Driver/Driver.cpp:1817:7
#68 0x00005645a740c4df clang_main(int, char**) /home/rupprecht/src/llvm-project/clang/tools/driver/driver.cpp:555:9

[rupprecht]

Actually, that assertion failure is pre-existing. However, this is newly failing in a no-asserts clang, so I wonder if something about this patch is just surfacing an existing bug in clang. Anyway, I hope to have a better repro by EOD.

[rupprecht]

Here's a well-formed reproducer:

struct MyStringView {
  MyStringView(const char *);
};

struct SourceLocation {
  static SourceLocation current(const char * = __builtin_FILE(),
                                unsigned int = __builtin_LINE());
};

template <typename T>
int Wrap(T);

template <typename>
struct Fixed {
  using name = MyStringView;
};

struct Metadata {
  Metadata(SourceLocation = SourceLocation::current());
};

struct Name {
  Name(int *);
};

template <typename... Fields>
struct C {
  static C New(Name, typename Fixed<Fields>::name..., Metadata);
};
struct X {
  int &x();
};
struct Foo {
  X x;
  int i = Wrap(C<int, int>::New(&x.x(), "", "", Metadata()));
};
void func() { new Foo{}; }

[cor3ntin]

In D136554#3996643, @rupprecht wrote:

Here's a well-formed reproducer:

Thanks a lot.
We were transforming the initializer in a context where the this pointer was not set up properly, so if it was referring to this, explicitly or implicitly, it would crash.

[cor3ntin]

Properly transform the this pointer in member initializers
that need to be rewritten.

[rupprecht]

I applied this version of the patch and the crash is now gone 🎉

However, now I get this inexplicable error -- I'm not entirely sure it's related, maybe I'm holding it wrong:

In module '<foo>':
foo.h$line:$num: error: 'foo::FooClass' has different definitions in different modules; first difference is definition in module 'something.h' found data member 'kFooDelimiter' with an initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
foo.h:$line:$num note: but in 'other.h' found data member 'kFooDelimiter' with a different initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~

The definition seems straightforward:

class FooClass final {
  ...
  static constexpr char kFooDelimiter = '+';
  ...
};

[cor3ntin]

In D136554#4000363, @rupprecht wrote:

I applied this version of the patch and the crash is now gone 🎉

However, now I get this inexplicable error -- I'm not entirely sure it's related, maybe I'm holding it wrong:

In module '<foo>':
foo.h$line:$num: error: 'foo::FooClass' has different definitions in different modules; first difference is definition in module 'something.h' found data member 'kFooDelimiter' with an initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
foo.h:$line:$num note: but in 'other.h' found data member 'kFooDelimiter' with a different initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~

The definition seems straightforward:

class FooClass final {
  ...
  static constexpr char kFooDelimiter = '+';
  ...
};

This is *very* surprising to me.
I could explain it if the member was not static though, as it would be the kind of things the patch affects. But static data members are handled very differently.

Was that liking chrome? It didn't come up in my tests

[rupprecht]

Sorry for the delay, I was out on vacation for a bit. I have a repro for this new issue now:

repro.tar.gz1 KBDownload

$ CLANG=~/dev/clang ./repro.sh
++ dirname /tmp/repro/repro.sh
+ DIR=/tmp/repro
+ : /tmp/D136554
+ rm -rf /tmp/D136554
+ mkdir -p /tmp/D136554
+ cd /tmp/D136554
+ cp /tmp/repro/lib.h /tmp/repro/outer.h /tmp/repro/x.h /tmp/repro/y.h /tmp/repro/z.h /tmp/repro/lib.cppmap /tmp/repro/outer.cppmap /tmp/repro/x.cppmap /tmp/repro/y.cppmap /tmp/repro/z.cppmap .
+ COMMON_ARGS=('-Wno-mismatched-tags' '-Xclang=-fmodules-embed-all-files' '-Xclang=-fmodules-local-submodule-visibility' '-fmodules' '-fno-implicit-modules' '-fno-implicit-module-maps' '-std=gnu++17' '-Xclang=-fmodule-map-file-home-is-cwd')
+ export COMMON_ARGS
+ /home/rupprecht/dev/clang -Wno-mismatched-tags -Xclang=-fmodules-embed-all-files -Xclang=-fmodules-local-submodule-visibility -fmodules -fno-implicit-modules -fno-implicit-module-maps -std=gnu++17 -Xclang=-fmodule-map-file-home-is-cwd -fmodule-name=x -fmodule-map-file=x.cppmap -fmodule-map-file=lib.cppmap -xc++ -Xclang=-emit-module -c x.cppmap -o x.pcm
+ /home/rupprecht/dev/clang -Wno-mismatched-tags -Xclang=-fmodules-embed-all-files -Xclang=-fmodules-local-submodule-visibility -fmodules -fno-implicit-modules -fno-implicit-module-maps -std=gnu++17 -Xclang=-fmodule-map-file-home-is-cwd -fmodule-name=y -fmodule-map-file=y.cppmap -fmodule-map-file=lib.cppmap -fmodule-map-file=z.cppmap -xc++ -Xclang=-emit-module -c y.cppmap -o y.pcm
+ /home/rupprecht/dev/clang -Wno-mismatched-tags -Xclang=-fmodules-embed-all-files -Xclang=-fmodules-local-submodule-visibility -fmodules -fno-implicit-modules -fno-implicit-module-maps -std=gnu++17 -Xclang=-fmodule-map-file-home-is-cwd -fmodule-name=outer -fmodule-map-file=outer.cppmap -Xclang=-fmodule-file=x.pcm -Xclang=-fmodule-file=y.pcm -fmodule-map-file=lib.cppmap -fmodule-map-file=x.cppmap -fmodule-map-file=y.cppmap -xc++-header -fsyntax-only -c outer.h -o outer.h.processed
In module 'x':
./lib.h:5:25: error: 'Foo' has different definitions in different modules; first difference is definition in module 'x.x.h' found data member 'kConstant' with an initializer
  static constexpr char kConstant = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~
./lib.h:5:25: note: but in 'y.y.h' found data member 'kConstant' with a different initializer
  static constexpr char kConstant = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~
1 error generated.

In D136554#4000654, @cor3ntin wrote:

In D136554#4000363, @rupprecht wrote:

I applied this version of the patch and the crash is now gone 🎉

However, now I get this inexplicable error -- I'm not entirely sure it's related, maybe I'm holding it wrong:

In module '<foo>':
foo.h$line:$num: error: 'foo::FooClass' has different definitions in different modules; first difference is definition in module 'something.h' found data member 'kFooDelimiter' with an initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
foo.h:$line:$num note: but in 'other.h' found data member 'kFooDelimiter' with a different initializer
  static constexpr char kFooDelimiter = '+';
  ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~

The definition seems straightforward:

class FooClass final {
  ...
  static constexpr char kFooDelimiter = '+';
  ...
};

This is *very* surprising to me.
I could explain it if the member was not static though, as it would be the kind of things the patch affects. But static data members are handled very differently.

Was that liking chrome? It didn't come up in my tests

No, it's some other internal target. There isn't any way for you to be able to test against these targets, so unfortunately the best I can offer is I'll patch in any updated versions of this patch, see what breaks, and try to reduce it when reporting.

There's barely any code in the repro I attached, it's just a bunch of header/module layering. My guess is that clang is usually able to see that the two definitions in different modules is the same and therefore dedupes them, but this change adds some unique bit of information that makes clang think it's different. Note that the headers need to be in a particular order to break.

[cor3ntin]

Thanks @rupprecht

As all good bugs, this was very confusing up
until the moment it became obvious.

I did not make the initializer a full expression during parsing,
(but on use), as I thought that was unecessary.
But then if that initializer had any cleanup, the next expression
being parsed would get cleanups instead.

So here kFooDelimiter initializer would be wrapped in ExprWithCleanup
(it clearly should not), if an only if Xyz was parsed before hand.

I added an ast dump test for that case.

[rupprecht]

Glad the test case made sense to you, it was convoluted to me :)

Still seeing one more error, and it's not modules-related so I might be able to get it reduced today. Generally, it looks like this:

struct Inner {
  Foo& foo;
  const std::unique_ptr<...> x = blah(blah(
      &foo.bar()));
};

class Outer {
 private:
  Foo foo_;
  Inner inner{foo_};
}

With the error being:

error: 'Inner::foo' is not a member of class 'Outer'
      &foo.bar()));

I think this build failure is wrong? foo should be referring to the definition inside Inner, but clang seems to be expecting it to refer to something in Outer.

Is it expected that this patch will cause some previously "working" code to no longer build? At some point I expect to hand you a reduction that's actually a bug in the user code.

[rupprecht]

In D136554#4013463, @rupprecht wrote:

Glad the test case made sense to you, it was convoluted to me :)

Still seeing one more error, and it's not modules-related so I might be able to get it reduced today. Generally, it looks like this:

struct Inner {
  Foo& foo;
  const std::unique_ptr<...> x = blah(blah(
      &foo.bar()));
};

class Outer {
 private:
  Foo foo_;
  Inner inner{foo_};
}

With the error being:

error: 'Inner::foo' is not a member of class 'Outer'
      &foo.bar()));

I think this build failure is wrong? foo should be referring to the definition inside Inner, but clang seems to be expecting it to refer to something in Outer.

Is it expected that this patch will cause some previously "working" code to no longer build? At some point I expect to hand you a reduction that's actually a bug in the user code.

Fully reduced as:

template <typename a, typename b> int c(a, b);
struct d {
  static d e(const char * = __builtin_FILE());
};
struct f {
  f(d = d::e());
};
struct h {
  int &g;
  int blah = c(g, f());
};
struct k {
  k();
  int i;
  h j{i};
};
k::k() {}

With the error: repro.cc:10:16: error: 'h::g' is not a member of class 'k'

[cor3ntin]

I hope we will get there...

It further reduces to

consteval void immediate(){};

struct h {
  int g = 0;
  int blah = (immediate(), g);
};
struct k {
 h j{};
}_;

The issue was that nested expressions are all transformed in the context of
the outermost (k) class and transforming the this pointer pick up
the current this pointer.
Because when we do the replacenent we no longer have templates,
we can just skip the transformation of the this pointer.

This is a cleaner way to handke the this pointer than
having a CXXThisScopeRAII on the outer scope,
so I removed that.

[rupprecht]

All good now! The latest revision of this patch doesn't seem to break anything, unless I ran our tests wrong. From my perspective this is OK to reland now.

[rupprecht]

In D136554#4018870, @rupprecht wrote:

All good now! The latest revision of this patch doesn't seem to break anything, unless I ran our tests wrong. From my perspective this is OK to reland now.

... and yep, I was holding it wrong. There are still build failures, this time in linking, where LLD reports some symbols are undefined. I'm not certain yet if this really a problem with this patch (e.g. sometimes we see files break like this when users put their template code in the .cpp files and not the .h files), but the source code doesn't look immediately wrong. Once again, I'll try to reduce something.

[rupprecht]

I'm not sure what to make of the new failure when I try it out this time. Given a source like this:

#include <functional>

struct Options {
  std::function<bool(bool x)> identity = [](bool x) -> bool { return x; };
};

struct Wrapper {
  explicit Wrapper(const Options& options = Options()) {}
};

void Func() { Options options; }

The object file reports many fewer symbols as a result of this patch, but one new problematic one. Before:

0000000000000000 T Func()
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::target_type() const
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::target(std::type_info const&) const
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::__clone(std::__1::__function::__base<bool (bool)>*) const
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::__clone() const
0000000000000000 W std::__1::__function::__base<bool (bool)>::~__base[abi:v160000]()
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::destroy_deallocate()
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::destroy()
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::~__func()
0000000000000000 W std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>::operator()(bool&&)
0000000000000000 V typeinfo for Options::identity::'lambda'(bool)
0000000000000000 V typeinfo for std::__1::__function::__base<bool (bool)>
0000000000000000 V typeinfo for std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>
0000000000000000 V typeinfo name for Options::identity::'lambda'(bool)
0000000000000000 V typeinfo name for std::__1::__function::__base<bool (bool)>
0000000000000000 V typeinfo name for std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>
                 U vtable for __cxxabiv1::__class_type_info
                 U vtable for __cxxabiv1::__si_class_type_info
0000000000000000 V vtable for std::__1::__function::__func<Options::identity::'lambda'(bool), std::__1::allocator<Options::identity::'lambda'(bool)>, bool (bool)>
                 U operator delete(void*)
                 U operator new(unsigned long)

And after:

0000000000000000 T Func()
                 U std::__1::function<bool (bool)>::function<Options::identity::'lambda'(bool), void>(Options::identity::'lambda'(bool))

The undefined symbols before are all provided by libc++, so those are fine. After, the new undefined symbol for the lambda cannot be resolved. Depending on how the linker is invoked, this may or may not be fine -- IIUC the linker can sometimes recognize that it doesn't actually need the undefined symbol, so it doesn't matter if it can't find it.

Here is the build script I'm using, although you will likely need to tweak it for your own environment:

${CLANG} \
  -std=gnu++17 -stdlib=libc++ \
  -c main.cc \
  -o /tmp/main.o

echo "main.o symbols:"
llvm-nm -C /tmp/main.o

echo Building b.cc

${CLANG} \
  -std=gnu++17 -stdlib=libc++ \
  -O1 -fno-exceptions \
  -c b.cc \
  -o /tmp/b.o

echo "b.o symbols:"
llvm-nm -C /tmp/b.o

echo Linking, and expecting success

${CLANG} \
  -fuse-ld=lld \
  -o /tmp/main \
  /tmp/main.o \
  -Wl,--start-lib /tmp/b.o -Wl,--end-lib \
  /usr/lib/x86_64-linux-gnu/libc++.so

echo Linking, and expecting failure with D136554

${CLANG} \
  -fuse-ld=lld \
  -o /tmp/main \
  /tmp/main.o \
  /tmp/b.o \
  /usr/lib/x86_64-linux-gnu/libc++.so \
  -Wl,--export-dynamic

(Here b.cc is the first snippet above, and main.cc is a trivial file with just int main(int argc, char* argv[]) { return 0; })

[MaskRay]

In D136554#4019135, @rupprecht wrote:

[...]
The undefined symbols before are all provided by libc++, so those are fine. After, the new undefined symbol for the lambda cannot be resolved. Depending on how the linker is invoked, this may or may not be fine -- IIUC the linker can sometimes recognize that it doesn't actually need the undefined symbol, so it doesn't matter if it can't find it.

Here is the build script I'm using, although you will likely need to tweak it for your own environment:

The linker behavior is expected. The "undefined symbol" error does show a defect of this patch.

For /tmp/main.o -Wl,--start-lib /tmp/b.o -Wl,--end-lib, b.o is a lazy object file (with archive semantics) which is not extracted.
The result is as if the linker discards the input file, so its undefined references do not cause a linker error ([[ https://maskray.me/blog/2021-06-13-dependency-related-linker-options#z-defs | -z defs ]]: unresolved undefined non-weak symbol from a relocatable object file; an unextracted lazy file is not considered a relocatable object file ).

For /tmp/main.o /tmp/b.o, b.o is parsed as a relocatable object file. Its undefined reference causes by this patch (experiment locally with git revert -n 339a7687e1c036a5f91c9d5391523b93e2e76cd3) leads to a -z defs linker error.

[cor3ntin]

Another fun one.
I really apreciate your help on this.

The constructor of Wrapper causes
the constructor of Option to be defined, but not yet used
(as default parameters are not odr used) -
so none of the default member initializers where marked ODR used.

When Option::Option() is called by Func, it is marked
as referenced and ODR used, but its default member initializers
are not.

When marking a constructor as referenced, we therefore must make sure
to reference its default member initializers.

[rupprecht]

I threw this at the "test everything" test (some millions of targets) and it found only one breakage, so this is very very close. Without further ado, here is this silly looking thing:

File blah.h:

#include <functional>
#include <memory>

template <typename T>
struct Base {
  virtual ~Base() = default;
};

class Impl : public Base<int> {};

struct ImplHolder {
  std::unique_ptr<Base<int>> impl = std::make_unique<Impl>();
};

struct GetImplCreators {
  std::function<ImplHolder()> impl_creator = []() { return ImplHolder{}; };
};

void UseImpl(GetImplCreators impl_creators = GetImplCreators{});

And blah.cc:

#include "blah.h"

void UseImpl(GetImplCreators impl_creators) {}

And lastly, blah_main.cc:

#include "blah.h"

void Func1() { UseImpl(); }
// Note: it also fails when we explicitly specify the default arg, in case that is interesting.
// void Func2() { UseImpl(GetImplCreators()); }

int main(int argc, char* argv[]) { return 0; }

And here's the LLD output:

ld: error: undefined hidden symbol: std::__u::__unique_if<Impl>::__unique_single std::__u::make_unique<Impl>()
>>> referenced by blah_main.cc
>>>               blah_main.o:(ImplHolder std::__u::__function::__policy_invoker<ImplHolder ()>::__call_impl<std::__u::__function::__default_alloc_func<GetImplCreators::impl_creator::'lambda'(), ImplHolder ()>>(std::__u::__function::__policy_storage const*))

ld: error: undefined hidden symbol: std::__u::unique_ptr<Impl, std::__u::default_delete<Impl>>::~unique_ptr()
>>> referenced by blah_main.cc
>>>               blah_main.o:(ImplHolder std::__u::__function::__policy_invoker<ImplHolder ()>::__call_impl<std::__u::__function::__default_alloc_func<GetImplCreators::impl_creator::'lambda'(), ImplHolder ()>>(std::__u::__function::__policy_storage const*))

I'm out of time today so I don't have a repro script to offer, but I can dig into that when I get back next year if the source-only example is insufficient.

[cor3ntin]

Finding the issue took about all day.
I reduced your example to

template <typename a>
int templated_func() {
    return 0;
}
struct test_body {
  int mem = templated_func<int>();
};

struct S {
  int a = [] { test_body{}; return 0;}(); // #1
} s;

When parsing the lambda #1 , we were not considering test_body{} to be
odr used, on account of the lambda being in the default initializer of a.

However, as it turns out, expressions in the body of a lambda are always
considered ODR used even if the lambda appear in a default parameter,
which I think makes sense.
(as the standard specifies that the body of a lambda is not a sub expression)

The actual code fix is to simplify the check we do to see if we are
in a nested default initializer.

[MaskRay]

@rupprecht You may consider contributing some interesting tests (which work before this patch) in a separate patch:)

[cor3ntin]

In D136554#4020387, @MaskRay wrote:

@rupprecht You may consider contributing some interesting tests (which work before this patch) in a separate patch:)

Well, all the failures reported have been reduced and added as test cases.
The coverage for member initializers was a bit spotty, that's for sure!

[rupprecht]

I still see one behavior change (actually it was there before, but I missed it in the test results), but as far as I can tell, it's a good one? If I reduce it too much, I get the warning with the baseline toolchain, so it's not erroneous AFAICT. Although I won't pretend I know all the intricacies of static and inline.

// a.h
static const std::pair<double, double>& GetFakePair() {
  static constexpr std::pair<double, double> kFakePair = {123.0, 456.0};
  return kFakePair;
}

// b.h
#include "a.h"

class X {
  void Foo(..., const std::pair<double, double>& x = GetFakePair()) const;
};

// main.cc, compiled with -Wunused-function
#include "b.h"
int main() { return 0; }

Yields this error:

In file included from main.cc:9:
In file included from ./b.h:16:
./a.h:40:41: error: 'static' function 'GetFakePair' declared in header file should be declared 'static inline' [-Werror,-Wunneeded-internal-declaration]
static const std::pair<double, double>& GetFakePair() {

Unless I'm missing something, it seems that, in regards to this warning, this change is just enabling an existing warning to have more coverage, and therefore this change looks ready to ship. Thanks for letting me provide all my repros before landing this one again :)

[rupprecht]

In D136554#4024628, @rupprecht wrote:

I still see one behavior change (actually it was there before, but I missed it in the test results), but as far as I can tell, it's a good one? If I reduce it too much, I get the warning with the baseline toolchain, so it's not erroneous AFAICT. Although I won't pretend I know all the intricacies of static and inline.

I missed another place in the unreduced repro that was referencing this method, and that was the trick. I reduced the newly-enabled warning case to this:

// a.h
static const std::pair<double, double>& GetFakePairRef() {
  static constexpr std::pair<double, double> fake = {1.0, 2.0};
  return fake;
}

struct Metadata {
  const std::pair<double, double>& data = GetFakePairRef();
};

// main.cc, compiled with -Wunused-function
#include "a.h"
int main() { return 0; }

Again, still LGTM.

[cor3ntin]

In D136554#4024719, @rupprecht wrote:

In D136554#4024628, @rupprecht wrote:

I still see one behavior change (actually it was there before, but I missed it in the test results), but as far as I can tell, it's a good one? If I reduce it too much, I get the warning with the baseline toolchain, so it's not erroneous AFAICT. Although I won't pretend I know all the intricacies of static and inline.

I missed another place in the unreduced repro that was referencing this method, and that was the trick. I reduced the newly-enabled warning case to this:

// a.h
static const std::pair<double, double>& GetFakePairRef() {
  static constexpr std::pair<double, double> fake = {1.0, 2.0};
  return fake;
}

struct Metadata {
  const std::pair<double, double>& data = GetFakePairRef();
};

// main.cc, compiled with -Wunused-function
#include "a.h"
int main() { return 0; }

Again, still LGTM.

Yes, this is a nice improvement.
It make sense. We now only mark default member initializers odr used when they are actually odr used.
default constructing an instance of MetaData silences the warning, which is expected!

I'll probably land today.
Thanks a lot for helping me find and reduce all of these corner cases, it was very useful and appreciated :)

[cor3ntin]

I found a new issue doing a bootstrap build, I'm currently reducing

[cor3ntin]

reduced to this lovely thing

template <typename e, bool = __is_constructible(e)> struct f {};
template <class k, f<k>> int l;
int m;
struct p {
  int o = m;
  p() {}
};

int i(l<p, false>);

SemaExpr.cpp:19857: void DoMarkVarDeclReferenced(clang::Sema &, clang::SourceLocation, clang::VarDecl *, clang::Expr *, llvm::DenseMap<const VarDecl *, int> &): Assertion `(!E || isa<FunctionParmPackExpr>(E)) && "missing non-odr-use marking for unevaluated decl ref"' failed.

[MaskRay]

In D136554#4021754, @cor3ntin wrote:

In D136554#4020387, @MaskRay wrote:

@rupprecht You may consider contributing some interesting tests (which work before this patch) in a separate patch:)

Well, all the failures reported have been reduced and added as test cases.
The coverage for member initializers was a bit spotty, that's for sure!

Thanks for checking! I was asking whether some tests worked before the patch and served as good regression tests. Then they can be pushed separately.

[cor3ntin]

I've convinced myself that the assertition case should be removed.

Before this patch, CXXDefaultInitExpr where never visited
by UsedDeclVisitor.

After this patch, when doing that visitation,
a variable can appear in an unevaluated context without having been mark
non odr used (and doing so would require to unconditionally transform
default member initializers, which we want to avoid).

[cor3ntin]

formatting

[cor3ntin]

Unless something else pops up, I'll try to land that this week end.

[cebowleratibm]

I've reduced a regression on:

commit ca619613801233ef2def8c3cc7d311d5ed0033cb (HEAD, refs/bisect/bad)
Author: Corentin Jabot <[e-mail]>
Date: Sun Oct 23 17:32:58 2022 +0200

template <class T> int f(T) { return 42; }

struct A {
   int x = f(A());
   A() { }
};

void foo() { A(); }

clang++ t2.C -c
t2.C:4:12: warning: stack nearly exhausted; compilation time may suffer, and crashes due to stack overflow are likely [-Wstack-exhausted]
   int x = f(A());
           ^
Segmentation fault (core dumped)

@cor3ntin would you like me to open a new issue? Admittedly the testcase is contrived but clang shouldn't seg fault on it.

[cor3ntin]

Yes please! However the warning looks correct to me in that case. A
constructs x which constructs A etc.

[cebowleratibm]

In D136554#4056862, @cor3ntin wrote:

Yes please! However the warning looks correct to me in that case. A
constructs x which constructs A etc.

https://github.com/llvm/llvm-project/issues/60082

Please set the project/labels as appropriate.

[aeubanks]

one more regression bisected to this: https://bugs.chromium.org/p/chromium/issues/detail?id=1408177
incomplete type 'blink::ResourceClient' used in type trait expression
I'll try to come up with a smaller repro

[aeubanks]

In D136554#4059723, @aeubanks wrote:

one more regression bisected to this: https://bugs.chromium.org/p/chromium/issues/detail?id=1408177
incomplete type 'blink::ResourceClient' used in type trait expression
I'll try to come up with a smaller repro

sorry, false alarm due to faulty bisection

clang/docs/ReleaseNotes.rst

 - Implemented `DR692 <https://wg21.link/cwg692>`_, `DR1395 <https://wg21.link/cwg1395>`_,
   and `DR1432 <https://wg21.link/cwg1432>`_. The fix for DR1432 is speculative since the
   issue is still open and has no proposed resolution at this time. A speculative fix
   for DR1432 is needed to prevent regressions that would otherwise occur due to DR692.
 - Clang's default C++/ObjC++ standard is now ``gnu++17`` instead of ``gnu++14``.
   This means Clang will by default accept code using features from C++17 and
   conforming GNU extensions. Projects incompatible with C++17 can add
   ``-std=gnu++14`` to their build settings to restore the previous behaviour.
 - Implemented DR2358 allowing init captures in lambdas in default arguments.
 - implemented `DR2654 <https://wg21.link/cwg2654>`_ which undeprecates
   all compound assignements operations on volatile qualified variables.
+- Implemented DR2631. Invalid ``consteval`` calls in default arguments and default
+  member initializers are diagnosed when and if the default is used.
+  This Fixes `Issue 56379 <https://github.com/llvm/llvm-project/issues/56379>`_
+  and changes the value of ``std::source_location::current()``
+  used in default parameters calls compared to previous versions of Clang.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`_).
   This fixes issues `Issue 52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `Issue 54300 <https://github.com/llvm/llvm-project/issues/54300>`_,
   `Issue 54301 <https://github.com/llvm/llvm-project/issues/54301>`_,
- Introduced the new function ``clang_getUnqualifiedType``, which mimics
   the behavior of ``QualType::getUnqualifiedType`` for ``CXType``.
 - Introduced the new function ``clang_getNonReferenceType``, which mimics
   the behavior of ``QualType::getNonReferenceType`` for ``CXType``.
 - Introduced the new function ``clang_CXXMethod_isDeleted``, which queries
   whether the method is declared ``= delete``.
 - Introduced the new function ``clang_CXXMethod_isCopyAssignmentOperator``,
   which identifies whether a method cursor is a copy-assignment
   operator.
 - Introduced the new function ``clang_CXXMethod_isMoveAssignmentOperator``,
   which identifies whether a method cursor is a move-assignment
   operator.
 - ``clang_Cursor_getNumTemplateArguments``, ``clang_Cursor_getTemplateArgumentKind``,
   ``clang_Cursor_getTemplateArgumentType``, ``clang_Cursor_getTemplateArgumentValue`` and
   ``clang_Cursor_getTemplateArgumentUnsignedValue`` now work on struct, class,
   and partial template specialization cursors in addition to function cursors.
 
 Static Analyzer
 ---------------
 - Removed the deprecated ``-analyzer-store`` and
   ``-analyzer-opt-analyze-nested-blocks`` analyzer flags.
   ``scanbuild`` was also updated accordingly.
   Passing these flags will result in a hard error.

clang/include/clang/AST/ExprCXX.h

public:
   }
 };
 
 /// A default argument (C++ [dcl.fct.default]).
 ///
 /// This wraps up a function call argument that was created from the
 /// corresponding parameter's default argument, when the call did not
 /// explicitly supply arguments for all of the parameters.
-class CXXDefaultArgExpr final : public Expr {
+class CXXDefaultArgExpr final
+    : public Expr,
+      private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
   friend class ASTStmtReader;
+  friend class ASTReader;
+  friend TrailingObjects;
 
   /// The parameter whose default is being used.
   ParmVarDecl *Param;
 
   /// The context where the default argument expression was used.
   DeclContext *UsedContext;
 
   CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
-                    DeclContext *UsedContext)
+                    Expr *RewrittenExpr, DeclContext *UsedContext)
       : Expr(SC,
              Param->hasUnparsedDefaultArg()
                  ? Param->getType().getNonReferenceType()
                  : Param->getDefaultArg()->getType(),
              Param->getDefaultArg()->getValueKind(),
              Param->getDefaultArg()->getObjectKind()),
         Param(Param), UsedContext(UsedContext) {
     CXXDefaultArgExprBits.Loc = Loc;
+    CXXDefaultArgExprBits.HasRewrittenInit = RewrittenExpr != nullptr;
+    if (RewrittenExpr)
+      *getTrailingObjects<Expr *>() = RewrittenExpr;
     setDependence(computeDependence(this));
   }
 
+  CXXDefaultArgExpr(EmptyShell Empty, bool HasRewrittenInit)
+      : Expr(CXXDefaultArgExprClass, Empty) {
+    CXXDefaultArgExprBits.HasRewrittenInit = HasRewrittenInit;
+  }
+
 public:
-  CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
+  static CXXDefaultArgExpr *CreateEmpty(const ASTContext &C,
+                                        bool HasRewrittenInit);
 
   // \p Param is the parameter whose default argument is used by this
   // expression.
   static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
-                                   ParmVarDecl *Param,
-                                   DeclContext *UsedContext) {
-    return new (C)
-        CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
-  }
-
+                                   ParmVarDecl *Param, Expr *RewrittenExpr,
+                                   DeclContext *UsedContext);
   // Retrieve the parameter that the argument was created from.
   const ParmVarDecl *getParam() const { return Param; }
   ParmVarDecl *getParam() { return Param; }
 
-  // Retrieve the actual argument to the function call.
-  const Expr *getExpr() const { return getParam()->getDefaultArg(); }
-  Expr *getExpr() { return getParam()->getDefaultArg(); }
+  bool hasRewrittenInit() const {
+    return CXXDefaultArgExprBits.HasRewrittenInit;
+  }
+
+  // Retrieve the argument to the function call.
+  Expr *getExpr();
+  const Expr *getExpr() const {
+    return const_cast<CXXDefaultArgExpr *>(this)->getExpr();
+  }
+
+  Expr *getRewrittenExpr() {
+    return hasRewrittenInit() ? *getTrailingObjects<Expr *>() : nullptr;
+  }
+
+  const Expr *getRewrittenExpr() const {
+    return const_cast<CXXDefaultArgExpr *>(this)->getRewrittenExpr();
+  }
+
+  // Retrieve the rewritten init expression (for an init expression containing
+  // immediate calls) with the top level FullExpr and ConstantExpr stripped off.
+  Expr *getAdjustedRewrittenExpr();
+  const Expr *getAdjustedRewrittenExpr() const {
+    return const_cast<CXXDefaultArgExpr *>(this)->getAdjustedRewrittenExpr();
+  }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default argument was actually used.
   SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
 
   /// Default argument expressions have no representation in the

 /// A use of a default initializer in a constructor or in aggregate
 /// initialization.
 ///
 /// This wraps a use of a C++ default initializer (technically,
 /// a brace-or-equal-initializer for a non-static data member) when it
 /// is implicitly used in a mem-initializer-list in a constructor
 /// (C++11 [class.base.init]p8) or in aggregate initialization
 /// (C++1y [dcl.init.aggr]p7).
-class CXXDefaultInitExpr : public Expr {
-  friend class ASTReader;
-  friend class ASTStmtReader;
+class CXXDefaultInitExpr final
+    : public Expr,
+      private llvm::TrailingObjects<CXXDefaultInitExpr, Expr *> {
 
+  friend class ASTStmtReader;
+  friend class ASTReader;
+  friend TrailingObjects;
   /// The field whose default is being used.
   FieldDecl *Field;
 
   /// The context where the default initializer expression was used.
   DeclContext *UsedContext;
 
   CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
-                     FieldDecl *Field, QualType Ty, DeclContext *UsedContext);
+                     FieldDecl *Field, QualType Ty, DeclContext *UsedContext,
+                     Expr *RewrittenInitExpr);
 
-  CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
+  CXXDefaultInitExpr(EmptyShell Empty, bool HasRewrittenInit)
+      : Expr(CXXDefaultInitExprClass, Empty) {
+    CXXDefaultInitExprBits.HasRewrittenInit = HasRewrittenInit;
+  }
 
 public:
+  static CXXDefaultInitExpr *CreateEmpty(const ASTContext &C,
+                                         bool HasRewrittenInit);
   /// \p Field is the non-static data member whose default initializer is used
   /// by this expression.
   static CXXDefaultInitExpr *Create(const ASTContext &Ctx, SourceLocation Loc,
-                                    FieldDecl *Field, DeclContext *UsedContext) {
-    return new (Ctx) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(), UsedContext);
+                                    FieldDecl *Field, DeclContext *UsedContext,
+                                    Expr *RewrittenInitExpr);
+
+  bool hasRewrittenInit() const {
+    return CXXDefaultInitExprBits.HasRewrittenInit;
   }
 
   /// Get the field whose initializer will be used.
   FieldDecl *getField() { return Field; }
   const FieldDecl *getField() const { return Field; }
 
   /// Get the initialization expression that will be used.
+  Expr *getExpr();
   const Expr *getExpr() const {
-    assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
-    return Field->getInClassInitializer();
+    return const_cast<CXXDefaultInitExpr *>(this)->getExpr();
   }
-  Expr *getExpr() {
-    assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
-    return Field->getInClassInitializer();
+
+  /// Retrieve the initializing expression with evaluated immediate calls, if
+  /// any.
+  const Expr *getRewrittenExpr() const {
+    assert(hasRewrittenInit() && "expected a rewritten init expression");
+    return *getTrailingObjects<Expr *>();
+  }
+
+  /// Retrieve the initializing expression with evaluated immediate calls, if
+  /// any.
+  Expr *getRewrittenExpr() {
+    assert(hasRewrittenInit() && "expected a rewritten init expression");
+    return *getTrailingObjects<Expr *>();
   }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default initializer expression was
   /// actually used.
   SourceLocation getUsedLocation() const { return getBeginLoc(); }
 

clang/include/clang/AST/Stmt.h

protected:
   };
 
   class CXXDefaultArgExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultArgExpr;
 
     unsigned : NumExprBits;
 
+    /// Whether this CXXDefaultArgExpr rewrote its argument and stores a copy.
+    unsigned HasRewrittenInit : 1;
+
     /// The location where the default argument expression was used.
     SourceLocation Loc;
   };
 
   class CXXDefaultInitExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultInitExpr;
 
     unsigned : NumExprBits;
 
+    /// Whether this CXXDefaultInitExprBitfields rewrote its argument and stores
+    /// a copy.
+    unsigned HasRewrittenInit : 1;
+
     /// The location where the default initializer expression was used.
     SourceLocation Loc;
   };
 
   class CXXScalarValueInitExprBitfields {
     friend class ASTStmtReader;
     friend class CXXScalarValueInitExpr;
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx14_compat_constexpr_not_const : Warning<
   "'constexpr' non-static member function will not be implicitly 'const' "
   "in C++14; add 'const' to avoid a change in behavior">,
   InGroup<DiagGroup<"constexpr-not-const">>;
 def err_invalid_consteval_take_address : Error<
   "cannot take address of consteval function %0 outside"
   " of an immediate invocation">;
 def err_invalid_consteval_call : Error<
   "call to consteval function %q0 is not a constant expression">;
+def note_invalid_consteval_initializer : Note<
+  "in the default initalizer of %0">;
+def note_invalid_consteval_initializer_here : Note<
+  "initialized here %0">;
 def err_invalid_consteval_decl_kind : Error<
   "%0 cannot be declared consteval">;
 def err_invalid_constexpr : Error<
   "%select{function parameter|typedef}0 "
   "cannot be %sub{select_constexpr_spec_kind}1">;
 def err_invalid_constexpr_member : Error<"non-static data member cannot be "
   "constexpr%select{; did you intend to make it %select{const|static}0?|}1">;
 def err_constexpr_tag : Error<

clang/include/clang/Sema/Sema.h

enum ExpressionKind {
       EK_Decltype, EK_TemplateArgument, EK_Other
     } ExprContext;
 
     // A context can be nested in both a discarded statement context and
     // an immediate function context, so they need to be tracked independently.
     bool InDiscardedStatement;
     bool InImmediateFunctionContext;
 
+    bool IsCurrentlyCheckingDefaultArgumentOrInitializer = false;
+
+    // When evaluating immediate functions in the initializer of a default
+    // argument or default member initializer, this is the declaration whose
+    // default initializer is being evaluated and the location of the call
+    // or constructor definition.
+    struct InitializationContext {
+      InitializationContext(SourceLocation Loc, ValueDecl *Decl,
+                            DeclContext *Context)
+          : Loc(Loc), Decl(Decl), Context(Context) {
+        assert(Decl && Context && "invalid initialization context");
+      }
+
+      SourceLocation Loc;
+      ValueDecl *Decl = nullptr;
+      DeclContext *Context = nullptr;
+    };
+    llvm::Optional<InitializationContext> DelayedDefaultInitializationContext;
+
     ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
                                       unsigned NumCleanupObjects,
                                       CleanupInfo ParentCleanup,
                                       Decl *ManglingContextDecl,
                                       ExpressionKind ExprContext)
         : Context(Context), ParentCleanup(ParentCleanup),
           NumCleanupObjects(NumCleanupObjects), NumTypos(0),
           ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext),
public:
   BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                         NamedDecl *FoundDecl,
                         CXXConstructorDecl *Constructor, bool Elidable,
                         MultiExprArg Exprs, bool HadMultipleCandidates,
                         bool IsListInitialization,
                         bool IsStdInitListInitialization, bool RequiresZeroInit,
                         unsigned ConstructKind, SourceRange ParenRange);
 
+  ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr,
+                                                SourceLocation InitLoc);
+
   ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
 
 
   /// Instantiate or parse a C++ default argument expression as necessary.
   /// Return true on error.
   bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
-                              ParmVarDecl *Param);
+                              ParmVarDecl *Param, Expr *Init = nullptr,
+                              bool SkipImmediateInvocations = true);
 
   /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
   /// the default expr if needed.
-  ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
-                                    FunctionDecl *FD,
-                                    ParmVarDecl *Param);
+  ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
+                                    ParmVarDecl *Param, Expr *Init = nullptr);
 
   /// FinalizeVarWithDestructor - Prepare for calling destructor on the
   /// constructed variable.
   void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
 
   /// Helper class that collects exception specifications for
   /// implicitly-declared special member functions.
   class ImplicitExceptionSpecification {

   }
 
   bool isImmediateFunctionContext() const {
     assert(!ExprEvalContexts.empty() &&
            "Must be in an expression evaluation context");
     return ExprEvalContexts.back().isImmediateFunctionContext();
   }
 
+  bool isCheckingDefaultArgumentOrInitializer() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    const ExpressionEvaluationContextRecord &Ctx = ExprEvalContexts.back();
+    return (Ctx.Context ==
+            ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed) ||
+           Ctx.IsCurrentlyCheckingDefaultArgumentOrInitializer;
+  }
+
+  llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
+  InnermostDeclarationWithDelayedImmediateInvocations() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    for (const auto &Ctx : llvm::reverse(ExprEvalContexts)) {
+      if (Ctx.Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
+          Ctx.DelayedDefaultInitializationContext)
+        return Ctx.DelayedDefaultInitializationContext;
+      if (Ctx.isConstantEvaluated() || Ctx.isImmediateFunctionContext() ||
+          Ctx.isUnevaluated())
+        break;
+    }
+    return std::nullopt;
+  }
+
+  llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
+  OutermostDeclarationWithDelayedImmediateInvocations() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
+        Res;
+    for (auto &Ctx : llvm::reverse(ExprEvalContexts)) {
+      if (Ctx.Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
+          !Ctx.DelayedDefaultInitializationContext && Res)
+        break;
+      if (Ctx.isConstantEvaluated() || Ctx.isImmediateFunctionContext() ||
+          Ctx.isUnevaluated())
+        break;
+      Res = Ctx.DelayedDefaultInitializationContext;
+    }
+    return Res;
+  }
+
   /// RAII class used to determine whether SFINAE has
   /// trapped any errors that occur during template argument
   /// deduction.
   class SFINAETrap {
     Sema &SemaRef;
     unsigned PrevSFINAEErrors;
     bool PrevInNonInstantiationSFINAEContext;
     bool PrevAccessCheckingSFINAE;
     bool PrevLastDiagnosticIgnored;
 
   public:
     explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
       : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
         PrevInNonInstantiationSFINAEContext(
                                       SemaRef.InNonInstantiationSFINAEContext),

clang/lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   ParmVarDecl *ToParam = *ToParamOrErr;
   if (!ToParam->getDefaultArg()) {
     Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
     assert(FromParam && "ParmVarDecl was not imported?");
 
     if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
       return std::move(Err);
   }
-
+  Expr *RewrittenInit = nullptr;
+  if (E->hasRewrittenInit()) {
+    ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
+    if (!ExprOrErr)
+      return ExprOrErr.takeError();
+    RewrittenInit = ExprOrErr.get();
+  }
   return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
-                                   *ToParamOrErr, *UsedContextOrErr);
+                                   *ToParamOrErr, RewrittenInit,
+                                   *UsedContextOrErr);
 }
 
 ExpectedStmt
 ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (!ToField->getInClassInitializer()) {
     // CXXDefaultInitExpr work.
     auto ToInClassInitializerOrErr =
         import(E->getField()->getInClassInitializer());
     if (!ToInClassInitializerOrErr)
       return ToInClassInitializerOrErr.takeError();
     ToField->setInClassInitializer(*ToInClassInitializerOrErr);
   }
 
+  Expr *RewrittenInit = nullptr;
+  if (E->hasRewrittenInit()) {
+    ExpectedExpr ExprOrErr = import(E->getRewrittenExpr());
+    if (!ExprOrErr)
+      return ExprOrErr.takeError();
+    RewrittenInit = ExprOrErr.get();
+  }
+
   return CXXDefaultInitExpr::Create(Importer.getToContext(), *ToBeginLocOrErr,
-                                    ToField, *UsedContextOrErr);
+                                    ToField, *UsedContextOrErr, RewrittenInit);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto ToSubExpr = importChecked(Err, E->getSubExpr());
   auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());

clang/lib/AST/Decl.cpp

 
 Expr *ParmVarDecl::getDefaultArg() {
   assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
   assert(!hasUninstantiatedDefaultArg() &&
          "Default argument is not yet instantiated!");
 
   Expr *Arg = getInit();
   if (auto *E = dyn_cast_or_null<FullExpr>(Arg))
-    if (!isa<ConstantExpr>(E))
-      return E->getSubExpr();
 
   return Arg;
 }
 
 void ParmVarDecl::setDefaultArg(Expr *defarg) {
   ParmVarDeclBits.DefaultArgKind = DAK_Normal;
   Init = defarg;
 }

clang/lib/AST/ExprCXX.cpp

 #endif
   return getArg(0);
 }
 
 const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
   return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();
 }
 
+CXXDefaultArgExpr *CXXDefaultArgExpr::CreateEmpty(const ASTContext &C,
+                                                  bool HasRewrittenInit) {
+  size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
+  auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
+  return new (Mem) CXXDefaultArgExpr(EmptyShell(), HasRewrittenInit);
+}
+
+CXXDefaultArgExpr *CXXDefaultArgExpr::Create(const ASTContext &C,
+                                             SourceLocation Loc,
+                                             ParmVarDecl *Param,
+                                             Expr *RewrittenExpr,
+                                             DeclContext *UsedContext) {
+  size_t Size = totalSizeToAlloc<Expr *>(RewrittenExpr != nullptr);
+  auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
+  return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
+                                     RewrittenExpr, UsedContext);
+}
+
+Expr *CXXDefaultArgExpr::getExpr() {
+  return CXXDefaultArgExprBits.HasRewrittenInit ? getAdjustedRewrittenExpr()
+                                                : getParam()->getDefaultArg();
+}
+
+Expr *CXXDefaultArgExpr::getAdjustedRewrittenExpr() {
+  assert(hasRewrittenInit() &&
+         "expected this CXXDefaultArgExpr to have a rewritten init.");
+  Expr *Init = getRewrittenExpr();
+  if (auto *E = dyn_cast_if_present<FullExpr>(Init))
+    if (!isa<ConstantExpr>(E))
+      return E->getSubExpr();
+  return Init;
+}
+
 CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
                                        SourceLocation Loc, FieldDecl *Field,
-                                       QualType Ty, DeclContext *UsedContext)
+                                       QualType Ty, DeclContext *UsedContext,
+                                       Expr *RewrittenInitExpr)
     : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
            Ty->isLValueReferenceType()   ? VK_LValue
            : Ty->isRValueReferenceType() ? VK_XValue
                                          : VK_PRValue,
            /*FIXME*/ OK_Ordinary),
       Field(Field), UsedContext(UsedContext) {
   CXXDefaultInitExprBits.Loc = Loc;
+  CXXDefaultInitExprBits.HasRewrittenInit = RewrittenInitExpr != nullptr;
+
+  if (CXXDefaultInitExprBits.HasRewrittenInit)
+    *getTrailingObjects<Expr *>() = RewrittenInitExpr;
+
   assert(Field->hasInClassInitializer());
 
   setDependence(computeDependence(this));
 }
 
+CXXDefaultInitExpr *CXXDefaultInitExpr::CreateEmpty(const ASTContext &C,
+                                                    bool HasRewrittenInit) {
+  size_t Size = totalSizeToAlloc<Expr *>(HasRewrittenInit);
+  auto *Mem = C.Allocate(Size, alignof(CXXDefaultInitExpr));
+  return new (Mem) CXXDefaultInitExpr(EmptyShell(), HasRewrittenInit);
+}
+
+CXXDefaultInitExpr *CXXDefaultInitExpr::Create(const ASTContext &Ctx,
+                                               SourceLocation Loc,
+                                               FieldDecl *Field,
+                                               DeclContext *UsedContext,
+                                               Expr *RewrittenInitExpr) {
+
+  size_t Size = totalSizeToAlloc<Expr *>(RewrittenInitExpr != nullptr);
+  auto *Mem = Ctx.Allocate(Size, alignof(CXXDefaultInitExpr));
+  return new (Mem) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(),
+                                      UsedContext, RewrittenInitExpr);
+}
+
+Expr *CXXDefaultInitExpr::getExpr() {
+  assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
+  if (hasRewrittenInit())
+    return getRewrittenExpr();
+
+  return Field->getInClassInitializer();
+}
+
 CXXTemporary *CXXTemporary::Create(const ASTContext &C,
                                    const CXXDestructorDecl *Destructor) {
   return new (C) CXXTemporary(Destructor);
 }
 
 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,
                                                    CXXTemporary *Temp,
                                                    Expr* SubExpr) {

clang/lib/Parse/ParseCXXInlineMethods.cpp

void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) {
 
   // Consume the previously pushed token.
   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
 
   SourceLocation EqualLoc;
 
   Actions.ActOnStartCXXInClassMemberInitializer();
 
+  // The initializer isn't actually potentially evaluated unless it is
+  // used.
+  EnterExpressionEvaluationContext Eval(
+      Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed);
+
   ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false,
                                               EqualLoc);
 
   Actions.ActOnFinishCXXInClassMemberInitializer(MI.Field, EqualLoc,
                                                  Init.get());
 
   // The next token should be our artificial terminating EOF token.
   if (Tok.isNot(tok::eof)) {

clang/lib/Parse/ParseDeclCXX.cpp

 /// Prior to C++0x, the assignment-expression in an initializer-clause must
 /// be a constant-expression.
 ExprResult Parser::ParseCXXMemberInitializer(Decl *D, bool IsFunction,
                                              SourceLocation &EqualLoc) {
   assert(Tok.isOneOf(tok::equal, tok::l_brace) &&
          "Data member initializer not starting with '=' or '{'");
 
   EnterExpressionEvaluationContext Context(
-      Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, D);
+      Actions,
+      isa_and_present<FieldDecl>(D)
+          ? Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
+          : Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
+      D);
   if (TryConsumeToken(tok::equal, EqualLoc)) {
     if (Tok.is(tok::kw_delete)) {
       // In principle, an initializer of '= delete p;' is legal, but it will
       // never type-check. It's better to diagnose it as an ill-formed
       // expression than as an ill-formed deleted non-function member. An
       // initializer of '= delete p, foo' will never be parsed, because a
       // top-level comma always ends the initializer expression.
       const Token &Next = NextToken();

clang/lib/Sema/SemaDeclCXX.cpp

ExprResult Sema::ActOnRequiresClause(ExprResult ConstraintExpr) {
 
   if (DiagnoseUnexpandedParameterPack(ConstraintExpr.get(),
                                       UPPC_RequiresClause))
     return ExprError();
 
   return ConstraintExpr;
 }
 
+ExprResult Sema::ConvertMemberDefaultInitExpression(FieldDecl *FD,
+                                                    Expr *InitExpr,
+                                                    SourceLocation InitLoc) {
+  InitializedEntity Entity =
+      InitializedEntity::InitializeMemberFromDefaultMemberInitializer(FD);
+  InitializationKind Kind =
+      FD->getInClassInitStyle() == ICIS_ListInit
+          ? InitializationKind::CreateDirectList(InitExpr->getBeginLoc(),
+                                                 InitExpr->getBeginLoc(),
+                                                 InitExpr->getEndLoc())
+          : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
+  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
+  return Seq.Perform(*this, Entity, Kind, InitExpr);
+}
+
 /// This is invoked after parsing an in-class initializer for a
 /// non-static C++ class member, and after instantiating an in-class initializer
 /// in a class template. Such actions are deferred until the class is complete.
 void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
                                                   SourceLocation InitLoc,
                                                   Expr *InitExpr) {
   // Pop the notional constructor scope we created earlier.
   PopFunctionScopeInfo(nullptr, D);
void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
   if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
     FD->setInvalidDecl();
     FD->removeInClassInitializer();
     return;
   }
 
   ExprResult Init = InitExpr;
   if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
-    InitializedEntity Entity =
-        InitializedEntity::InitializeMemberFromDefaultMemberInitializer(FD);
-    InitializationKind Kind =
-        FD->getInClassInitStyle() == ICIS_ListInit
-            ? InitializationKind::CreateDirectList(InitExpr->getBeginLoc(),
-                                                   InitExpr->getBeginLoc(),
-                                                   InitExpr->getEndLoc())
-            : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
-    InitializationSequence Seq(*this, Entity, Kind, InitExpr);
-    Init = Seq.Perform(*this, Entity, Kind, InitExpr);
-    if (Init.isInvalid()) {
-      FD->setInvalidDecl();
-      return;
-    }
-  }
-
+    Init = ConvertMemberDefaultInitExpression(FD, InitExpr, InitLoc);
     // C++11 [class.base.init]p7:
     //   The initialization of each base and member constitutes a
     //   full-expression.
-  Init = ActOnFinishFullExpr(Init.get(), InitLoc, /*DiscardedValue*/ false);
+    if (!Init.isInvalid())
+      Init = ActOnFinishFullExpr(Init.get(), /*DiscarededValue=*/false);
     if (Init.isInvalid()) {
       FD->setInvalidDecl();
       return;
     }
+  }
 
   InitExpr = Init.get();
 
   FD->setInClassInitializer(InitExpr);
 }
 
 /// Find the direct and/or virtual base specifiers that
 /// correspond to the given base type, for use in base initialization
return CheckForImmediateInvocation(
           Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
           HadMultipleCandidates, IsListInitialization,
           IsStdInitListInitialization, RequiresZeroInit,
           static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
           ParenRange),
       Constructor);
 }
 
-ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
-  assert(Field->hasInClassInitializer());
-
-  // If we already have the in-class initializer nothing needs to be done.
-  if (Field->getInClassInitializer())
-    return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
-
-  // If we might have already tried and failed to instantiate, don't try again.
-  if (Field->isInvalidDecl())
-    return ExprError();
-
-  // Maybe we haven't instantiated the in-class initializer. Go check the
-  // pattern FieldDecl to see if it has one.
-  CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
-
-  if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
-    CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
-    DeclContext::lookup_result Lookup =
-        ClassPattern->lookup(Field->getDeclName());
-
-    FieldDecl *Pattern = nullptr;
-    for (auto *L : Lookup) {
-      if (isa<FieldDecl>(L)) {
-        Pattern = cast<FieldDecl>(L);
-        break;
-      }
-    }
-    assert(Pattern && "We must have set the Pattern!");
-
-    if (!Pattern->hasInClassInitializer() ||
-        InstantiateInClassInitializer(Loc, Field, Pattern,
-                                      getTemplateInstantiationArgs(Field))) {
-      // Don't diagnose this again.
-      Field->setInvalidDecl();
-      return ExprError();
-    }
-    return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
-  }
-
-  // DR1351:
-  //   If the brace-or-equal-initializer of a non-static data member
-  //   invokes a defaulted default constructor of its class or of an
-  //   enclosing class in a potentially evaluated subexpression, the
-  //   program is ill-formed.
-  //
-  // This resolution is unworkable: the exception specification of the
-  // default constructor can be needed in an unevaluated context, in
-  // particular, in the operand of a noexcept-expression, and we can be
-  // unable to compute an exception specification for an enclosed class.
-  //
-  // Any attempt to resolve the exception specification of a defaulted default
-  // constructor before the initializer is lexically complete will ultimately
-  // come here at which point we can diagnose it.
-  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
-  Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
-      << OutermostClass << Field;
-  Diag(Field->getEndLoc(),
-       diag::note_default_member_initializer_not_yet_parsed);
-  // Recover by marking the field invalid, unless we're in a SFINAE context.
-  if (!isSFINAEContext())
-    Field->setInvalidDecl();
-  return ExprError();
-}
-
 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
   if (VD->isInvalidDecl()) return;
   // If initializing the variable failed, don't also diagnose problems with
   // the destructor, they're likely related.
   if (VD->getInit() && VD->getInit()->containsErrors())
     return;
 
   CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());

clang/lib/Sema/SemaExpr.cpp

if (LHSExp->IgnoreParenImpCasts()->getType()->isVariablyModifiedType() &&
     }
   }
 
   return new (Context)
       ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc);
 }
 
 bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
-                                  ParmVarDecl *Param) {
+                                  ParmVarDecl *Param, Expr *RewrittenInit,
+                                  bool SkipImmediateInvocations) {
   if (Param->hasUnparsedDefaultArg()) {
+    assert(!RewrittenInit && "Should not have a rewritten init expression yet");
     // If we've already cleared out the location for the default argument,
     // that means we're parsing it right now.
     if (!UnparsedDefaultArgLocs.count(Param)) {
       Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
       Diag(CallLoc, diag::note_recursive_default_argument_used_here);
       Param->setInvalidDecl();
       return true;
     }
 
     Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
         << FD << cast<CXXRecordDecl>(FD->getDeclContext());
     Diag(UnparsedDefaultArgLocs[Param],
          diag::note_default_argument_declared_here);
     return true;
   }
 
-  if (Param->hasUninstantiatedDefaultArg() &&
-      InstantiateDefaultArgument(CallLoc, FD, Param))
+  if (Param->hasUninstantiatedDefaultArg()) {
+    assert(!RewrittenInit && "Should not have a rewitten init expression yet");
+    if (InstantiateDefaultArgument(CallLoc, FD, Param))
       return true;
+  }
 
-  assert(Param->hasInit() && "default argument but no initializer?");
+  Expr *Init = RewrittenInit ? RewrittenInit : Param->getInit();
+  assert(Init && "default argument but no initializer?");
 
   // If the default expression creates temporaries, we need to
   // push them to the current stack of expression temporaries so they'll
   // be properly destroyed.
   // FIXME: We should really be rebuilding the default argument with new
   // bound temporaries; see the comment in PR5810.
   // We don't need to do that with block decls, though, because
   // blocks in default argument expression can never capture anything.
-  if (auto Init = dyn_cast<ExprWithCleanups>(Param->getInit())) {
+  if (auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(Init)) {
     // Set the "needs cleanups" bit regardless of whether there are
     // any explicit objects.
-    Cleanup.setExprNeedsCleanups(Init->cleanupsHaveSideEffects());
-
+    Cleanup.setExprNeedsCleanups(InitWithCleanup->cleanupsHaveSideEffects());
     // Append all the objects to the cleanup list.  Right now, this
     // should always be a no-op, because blocks in default argument
     // expressions should never be able to capture anything.
-    assert(!Init->getNumObjects() &&
+    assert(!InitWithCleanup->getNumObjects() &&
            "default argument expression has capturing blocks?");
   }
-
-  // We already type-checked the argument, so we know it works.
-  // Just mark all of the declarations in this potentially-evaluated expression
-  // as being "referenced".
   EnterExpressionEvaluationContext EvalContext(
       *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
-  MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
-                                   /*SkipLocalVariables=*/true);
+  ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
+      SkipImmediateInvocations;
+  MarkDeclarationsReferencedInExpr(Init, /*SkipLocalVariables*/ true);
   return false;
 }
 
+struct ImmediateCallVisitor : public RecursiveASTVisitor<ImmediateCallVisitor> {
+  bool HasImmediateCalls = false;
+
+  bool shouldVisitImplicitCode() const { return true; }
+
+  bool VisitCallExpr(CallExpr *E) {
+    if (const FunctionDecl *FD = E->getDirectCallee())
+      HasImmediateCalls |= FD->isConsteval();
+    return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
+  }
+
+  // SourceLocExpr are not immediate invocations
+  // but CXXDefaultInitExpr/CXXDefaultArgExpr containing a SourceLocExpr
+  // need to be rebuilt so that they refer to the correct SourceLocation and
+  // DeclContext.
+  bool VisitSourceLocExpr(SourceLocExpr *E) {
+    HasImmediateCalls = true;
+    return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
+  }
+
+  // A nested lambda might have parameters with immediate invocations
+  // in their default arguments.
+  // The compound statement is not visited (as it does not constitute a
+  // subexpression).
+  // FIXME: We should consider visiting and transforming captures
+  // with init expressions.
+  bool VisitLambdaExpr(LambdaExpr *E) {
+    return VisitCXXMethodDecl(E->getCallOperator());
+  }
+
+  // Blocks don't support default parameters, and, as for lambdas,
+  // we don't consider their body a subexpression.
+  bool VisitBlockDecl(BlockDecl *B) { return false; }
+
+  bool VisitCompoundStmt(CompoundStmt *B) { return false; }
+
+  bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
+    return TraverseStmt(E->getExpr());
+  }
+
+  bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
+    return TraverseStmt(E->getExpr());
+  }
+};
+
+struct EnsureImmediateInvocationInDefaultArgs
+    : TreeTransform<EnsureImmediateInvocationInDefaultArgs> {
+  EnsureImmediateInvocationInDefaultArgs(Sema &SemaRef)
+      : TreeTransform(SemaRef) {}
+
+  // Lambda can only have immediate invocations in the default
+  // args of their parameters, which is transformed upon calling the closure.
+  // The body is not a subexpression, so we have nothing to do.
+  // FIXME: Immediate calls in capture initializers should be transformed.
+  ExprResult TransformLambdaExpr(LambdaExpr *E) { return E; }
+  ExprResult TransformBlockExpr(BlockExpr *E) { return E; }
+
+  // Make sure we don't rebuild the this pointer as it would
+  // cause it to incorrectly point it to the outermost class
+  // in the case of nested struct initialization.
+  ExprResult TransformCXXThisExpr(CXXThisExpr *E) { return E; }
+};
+
 ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
-                                        FunctionDecl *FD, ParmVarDecl *Param) {
+                                        FunctionDecl *FD, ParmVarDecl *Param,
+                                        Expr *Init) {
   assert(Param->hasDefaultArg() && "can't build nonexistent default arg");
-  if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
-    return ExprError();
-  return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
+
+  bool NestedDefaultChecking = isCheckingDefaultArgumentOrInitializer();
+
+  llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
+      InitializationContext =
+          OutermostDeclarationWithDelayedImmediateInvocations();
+  if (!InitializationContext.has_value())
+    InitializationContext.emplace(CallLoc, Param, CurContext);
+
+  if (!Init && !Param->hasUnparsedDefaultArg()) {
+    // Mark that we are replacing a default argument first.
+    // If we are instantiating a template we won't have to
+    // retransform immediate calls.
+    EnterExpressionEvaluationContext EvalContext(
+        *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
+
+    if (Param->hasUninstantiatedDefaultArg()) {
+      if (InstantiateDefaultArgument(CallLoc, FD, Param))
+        return ExprError();
+    }
+    // CWG2631
+    // An immediate invocation that is not evaluated where it appears is
+    // evaluated and checked for whether it is a constant expression at the
+    // point where the enclosing initializer is used in a function call.
+    ImmediateCallVisitor V;
+    if (!NestedDefaultChecking)
+      V.TraverseDecl(Param);
+    if (V.HasImmediateCalls) {
+      ExprEvalContexts.back().DelayedDefaultInitializationContext = {
+          CallLoc, Param, CurContext};
+      EnsureImmediateInvocationInDefaultArgs Immediate(*this);
+      ExprResult Res = Immediate.TransformInitializer(Param->getInit(),
+                                                      /*NotCopy=*/false);
+      if (Res.isInvalid())
+        return ExprError();
+      Res = ConvertParamDefaultArgument(Param, Res.get(),
+                                        Res.get()->getBeginLoc());
+      if (Res.isInvalid())
+        return ExprError();
+      Init = Res.get();
+    }
+  }
+
+  if (CheckCXXDefaultArgExpr(
+          CallLoc, FD, Param, Init,
+          /*SkipImmediateInvocations=*/NestedDefaultChecking))
+    return ExprError();
+
+  return CXXDefaultArgExpr::Create(Context, InitializationContext->Loc, Param,
+                                   Init, InitializationContext->Context);
+}
+
+ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
+  assert(Field->hasInClassInitializer());
+
+  // If we might have already tried and failed to instantiate, don't try again.
+  if (Field->isInvalidDecl())
+    return ExprError();
+
+  auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
+
+  llvm::Optional<ExpressionEvaluationContextRecord::InitializationContext>
+      InitializationContext =
+          OutermostDeclarationWithDelayedImmediateInvocations();
+  if (!InitializationContext.has_value())
+    InitializationContext.emplace(Loc, Field, CurContext);
+
+  Expr *Init = nullptr;
+
+  bool NestedDefaultChecking = isCheckingDefaultArgumentOrInitializer();
+
+  EnterExpressionEvaluationContext EvalContext(
+      *this, ExpressionEvaluationContext::PotentiallyEvaluated, Field);
+
+  if (!Field->getInClassInitializer()) {
+    // Maybe we haven't instantiated the in-class initializer. Go check the
+    // pattern FieldDecl to see if it has one.
+    if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
+      CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
+      DeclContext::lookup_result Lookup =
+          ClassPattern->lookup(Field->getDeclName());
+
+      FieldDecl *Pattern = nullptr;
+      for (auto *L : Lookup) {
+        if ((Pattern = dyn_cast<FieldDecl>(L)))
+          break;
+      }
+      assert(Pattern && "We must have set the Pattern!");
+      if (!Pattern->hasInClassInitializer() ||
+          InstantiateInClassInitializer(Loc, Field, Pattern,
+                                        getTemplateInstantiationArgs(Field))) {
+        Field->setInvalidDecl();
+        return ExprError();
+      }
+    }
+  }
+
+  // CWG2631
+  // An immediate invocation that is not evaluated where it appears is
+  // evaluated and checked for whether it is a constant expression at the
+  // point where the enclosing initializer is used in a [...] a constructor
+  // definition, or an aggregate initialization.
+  ImmediateCallVisitor V;
+  if (!NestedDefaultChecking)
+    V.TraverseDecl(Field);
+  if (V.HasImmediateCalls) {
+    ExprEvalContexts.back().DelayedDefaultInitializationContext = {Loc, Field,
+                                                                   CurContext};
+    ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
+        NestedDefaultChecking;
+
+    EnsureImmediateInvocationInDefaultArgs Immediate(*this);
+
+    ExprResult Res =
+        Immediate.TransformInitializer(Field->getInClassInitializer(),
+                                       /*CXXDirectInit=*/false);
+    if (!Res.isInvalid())
+      Res = ConvertMemberDefaultInitExpression(Field, Res.get(), Loc);
+    if (Res.isInvalid()) {
+      Field->setInvalidDecl();
+      return ExprError();
+    }
+    Init = Res.get();
+  }
+
+  if (Field->getInClassInitializer()) {
+    Expr *E = Init ? Init : Field->getInClassInitializer();
+    if (!NestedDefaultChecking)
+      MarkDeclarationsReferencedInExpr(E, /*SkipLocalVariables=*/false);
+    // C++11 [class.base.init]p7:
+    //   The initialization of each base and member constitutes a
+    //   full-expression.
+    ExprResult Res = ActOnFinishFullExpr(E, /*DiscardedValue=*/false);
+    if (Res.isInvalid()) {
+      Field->setInvalidDecl();
+      return ExprError();
+    }
+    Init = Res.get();
+
+    return CXXDefaultInitExpr::Create(Context, InitializationContext->Loc,
+                                      Field, InitializationContext->Context,
+                                      Init);
+  }
+
+  // DR1351:
+  //   If the brace-or-equal-initializer of a non-static data member
+  //   invokes a defaulted default constructor of its class or of an
+  //   enclosing class in a potentially evaluated subexpression, the
+  //   program is ill-formed.
+  //
+  // This resolution is unworkable: the exception specification of the
+  // default constructor can be needed in an unevaluated context, in
+  // particular, in the operand of a noexcept-expression, and we can be
+  // unable to compute an exception specification for an enclosed class.
+  //
+  // Any attempt to resolve the exception specification of a defaulted default
+  // constructor before the initializer is lexically complete will ultimately
+  // come here at which point we can diagnose it.
+  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
+  Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
+      << OutermostClass << Field;
+  Diag(Field->getEndLoc(),
+       diag::note_default_member_initializer_not_yet_parsed);
+  // Recover by marking the field invalid, unless we're in a SFINAE context.
+  if (!isSFINAEContext())
+    Field->setInvalidDecl();
 }
 
 Sema::VariadicCallType
 Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
                           Expr *Fn) {
   if (Proto && Proto->isVariadic()) {
     if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
       return VariadicConstructor;
if (BO->getOpcode() == BO_Assign) {
       llvm::erase_value(LHSs, BO->getLHS());
     }
   }
 }
 
 ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
   if (isUnevaluatedContext() || !E.isUsable() || !Decl ||
       !Decl->isConsteval() || isConstantEvaluated() ||
+      isCheckingDefaultArgumentOrInitializer() ||
       RebuildingImmediateInvocation || isImmediateFunctionContext())
     return E;
 
   /// Opportunistically remove the callee from ReferencesToConsteval if we can.
   /// It's OK if this fails; we'll also remove this in
   /// HandleImmediateInvocations, but catching it here allows us to avoid
   /// walking the AST looking for it in simple cases.
   if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
if (auto *FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
       InnerExpr = FunctionalCast->getSubExpr();
     FunctionDecl *FD = nullptr;
     if (auto *Call = dyn_cast<CallExpr>(InnerExpr))
       FD = cast<FunctionDecl>(Call->getCalleeDecl());
     else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
       FD = Call->getConstructor();
     else
       llvm_unreachable("unhandled decl kind");
-    assert(FD->isConsteval());
+    assert(FD && FD->isConsteval());
     SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
+    if (auto Context =
+            SemaRef.InnermostDeclarationWithDelayedImmediateInvocations()) {
+      SemaRef.Diag(Context->Loc, diag::note_invalid_consteval_initializer)
+          << Context->Decl;
+      SemaRef.Diag(Context->Decl->getBeginLoc(), diag::note_declared_at);
+    }
     for (auto &Note : Notes)
       SemaRef.Diag(Note.first, Note.second);
     return;
   }
   CE->MoveIntoResult(Eval.Val, SemaRef.getASTContext());
 }
 
 static void RemoveNestedImmediateInvocation(
runWithSufficientStackSpace(Loc, [&] {
         for (auto *i : Func->redecls()) {
           if (!i->isUsed(false) && i->isImplicitlyInstantiable())
             MarkFunctionReferenced(Loc, i, MightBeOdrUse);
         }
       }
     });
   }
 
+  // If a constructor was defined in the context of a default parameter
+  // or of another default member initializer (ie a PotentiallyEvaluatedIfUsed
+  // context), its initializers may not be referenced yet.
+  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
+    for (CXXCtorInitializer *Init : Constructor->inits()) {
+      if (Init->isInClassMemberInitializer())
+        MarkDeclarationsReferencedInExpr(Init->getInit());
+    }
+  }
+
   // C++14 [except.spec]p17:
   //   An exception-specification is considered to be needed when:
   //   - the function is odr-used or, if it appears in an unevaluated operand,
   //     would be odr-used if the expression were potentially-evaluated;
   //
   // Note, we do this even if MightBeOdrUse is false. That indicates that the
   // function is a pure virtual function we're calling, and in that case the
   // function was selected by overload resolution and we need to resolve its
bool Sema::tryCaptureVariable(
   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 = !VD->hasLocalStorage();
   if (IsGlobal &&
if (DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
     if (DRE->isNonOdrUse())
       return;
   if (MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
     if (ME->isNonOdrUse())
       return;
 
   switch (OdrUse) {
   case OdrUseContext::None:
-    assert((!E || isa<FunctionParmPackExpr>(E)) &&
+    // In some cases, a variable may not have been marked unevaluated, if it
+    // appears in a defaukt initializer.
+    assert((!E || isa<FunctionParmPackExpr>(E) ||
+            SemaRef.isUnevaluatedContext()) &&
            "missing non-odr-use marking for unevaluated decl ref");
     break;
 
   case OdrUseContext::FormallyOdrUsed:
     // FIXME: Ignoring formal odr-uses results in incorrect lambda capture
     // behavior.
     break;
 
void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
   bool OdrUse = true;
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
     if (Method->isVirtual() &&
         !Method->getDevirtualizedMethod(Base, getLangOpts().AppleKext))
       OdrUse = false;
 
   if (auto *FD = dyn_cast<FunctionDecl>(E->getDecl()))
     if (!isUnevaluatedContext() && !isConstantEvaluated() &&
-        !isImmediateFunctionContext() && FD->isConsteval() &&
+        !isImmediateFunctionContext() &&
+        !isCheckingDefaultArgumentOrInitializer() && FD->isConsteval() &&
         !RebuildingImmediateInvocation && !FD->isDependentContext())
       ExprEvalContexts.back().ReferenceToConsteval.insert(E);
   MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
                      RefsMinusAssignments);
 }
 
 /// Perform reference-marking and odr-use handling for a MemberExpr.
 void Sema::MarkMemberReferenced(MemberExpr *E) {

clang/lib/Sema/SemaTemplateInstantiate.cpp

TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
   return inherited::TransformDeclRefExpr(E);
 }
 
 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
     CXXDefaultArgExpr *E) {
   assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->
              getDescribedFunctionTemplate() &&
          "Default arg expressions are never formed in dependent cases.");
-  return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
-                           cast<FunctionDecl>(E->getParam()->getDeclContext()),
-                                        E->getParam());
+  return SemaRef.BuildCXXDefaultArgExpr(
+      E->getUsedLocation(), cast<FunctionDecl>(E->getParam()->getDeclContext()),
 }
 
 template<typename Fn>
 QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
                                  FunctionProtoTypeLoc TL,
                                  CXXRecordDecl *ThisContext,
                                  Qualifiers ThisTypeQuals,
                                  Fn TransformExceptionSpec) {
bool Sema::InstantiateInClassInitializer(
   PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
                                       "instantiating default member init");
 
   // Enter the scope of this instantiation. We don't use PushDeclContext because
   // we don't have a scope.
   ContextRAII SavedContext(*this, Instantiation->getParent());
   EnterExpressionEvaluationContext EvalContext(
       *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
+  ExprEvalContexts.back().DelayedDefaultInitializationContext = {
+      PointOfInstantiation, Instantiation, CurContext};
 
   LocalInstantiationScope Scope(*this, true);
 
   // Instantiate the initializer.
   ActOnStartCXXInClassMemberInitializer();
   CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), Qualifiers());
 
   ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,

clang/lib/Sema/TreeTransform.h

ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
     return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
   }
 
   /// Build a new C++ default-argument expression.
   ///
   /// By default, builds a new default-argument expression, which does not
   /// require any semantic analysis. Subclasses may override this routine to
   /// provide different behavior.
-  ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) {
+  ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param,
+                                      Expr *RewrittenExpr) {
     return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
-                                     getSema().CurContext);
+                                     RewrittenExpr, getSema().CurContext);
   }
 
   /// Build a new C++11 default-initialization expression.
   ///
   /// By default, builds a new default field initialization expression, which
   /// does not require any semantic analysis. Subclasses may override this
   /// routine to provide different behavior.
   ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
                                        FieldDecl *Field) {
-    return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field,
-                                      getSema().CurContext);
+    return getSema().BuildCXXDefaultInitExpr(Loc, Field);
   }
 
   /// Build a new C++ zero-initialization expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
                                            SourceLocation LParenLoc,

 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
       getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
   if (!Param)
     return ExprError();
 
+  ExprResult InitRes;
+  if (E->hasRewrittenInit()) {
+    InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
+    if (InitRes.isInvalid())
+      return ExprError();
+  }
+
   if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
-      E->getUsedContext() == SemaRef.CurContext)
+      E->getUsedContext() == SemaRef.CurContext &&
+      InitRes.get() == E->getRewrittenExpr())
     return E;
 
-  return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
+  return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
+                                               InitRes.get());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   FieldDecl *Field = cast_or_null<FieldDecl>(
       getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
   if (!Field)

clang/lib/Sema/UsedDeclVisitor.h

if (!DestroyedOrNull.isNull()) {
       }
     }
 
     Inherited::VisitCXXDeleteExpr(E);
   }
 
   void VisitCXXConstructExpr(CXXConstructExpr *E) {
     asImpl().visitUsedDecl(E->getBeginLoc(), E->getConstructor());
+    CXXConstructorDecl *D = E->getConstructor();
+    for (const CXXCtorInitializer *Init : D->inits()) {
+      if (Init->isInClassMemberInitializer())
+        asImpl().Visit(Init->getInit());
+    }
     Inherited::VisitCXXConstructExpr(E);
   }
 
   void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
     asImpl().Visit(E->getExpr());
+    Inherited::VisitCXXDefaultArgExpr(E);
+  }
+
+  void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
+    asImpl().Visit(E->getExpr());
+    Inherited::VisitCXXDefaultInitExpr(E);
+  }
+
+  void VisitInitListExpr(InitListExpr *ILE) {
+    if (ILE->hasArrayFiller())
+      asImpl().Visit(ILE->getArrayFiller());
+    Inherited::VisitInitListExpr(ILE);
   }
 
   void visitUsedDecl(SourceLocation Loc, Decl *D) {
     if (auto *CD = dyn_cast<CapturedDecl>(D)) {
       if (auto *S = CD->getBody()) {
         asImpl().Visit(S);
       }
     } else if (auto *CD = dyn_cast<BlockDecl>(D)) {

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<ParmVarDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
   E->CXXDefaultArgExprBits.Loc = readSourceLocation();
+  E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
+  if (E->CXXDefaultArgExprBits.HasRewrittenInit)
+    *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
+  E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
   E->Field = readDeclAs<FieldDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
   E->CXXDefaultInitExprBits.Loc = readSourceLocation();
+  if (E->CXXDefaultInitExprBits.HasRewrittenInit)
+    *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
   E->setTemporary(Record.readCXXTemporary());
   E->setSubExpr(Record.readSubExpr());
 }
 
case EXPR_CXX_THIS:
       S = new (Context) CXXThisExpr(Empty);
       break;
 
     case EXPR_CXX_THROW:
       S = new (Context) CXXThrowExpr(Empty);
       break;
 
     case EXPR_CXX_DEFAULT_ARG:
-      S = new (Context) CXXDefaultArgExpr(Empty);
+      S = CXXDefaultArgExpr::CreateEmpty(
+          Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
       break;
 
     case EXPR_CXX_DEFAULT_INIT:
-      S = new (Context) CXXDefaultInitExpr(Empty);
+      S = CXXDefaultInitExpr::CreateEmpty(
+          Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
       break;
 
     case EXPR_CXX_BIND_TEMPORARY:
       S = new (Context) CXXBindTemporaryExpr(Empty);
       break;
 
     case EXPR_CXX_SCALAR_VALUE_INIT:
       S = new (Context) CXXScalarValueInitExpr(Empty);

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
   Code = serialization::EXPR_CXX_THROW;
 }
 
 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   Record.AddDeclRef(E->getParam());
   Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
   Record.AddSourceLocation(E->getUsedLocation());
+  Record.push_back(E->hasRewrittenInit());
+  if (E->hasRewrittenInit())
+    Record.AddStmt(E->getRewrittenExpr());
   Code = serialization::EXPR_CXX_DEFAULT_ARG;
 }
 
 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
+  Record.push_back(E->hasRewrittenInit());
   Record.AddDeclRef(E->getField());
   Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
   Record.AddSourceLocation(E->getExprLoc());
+  if (E->hasRewrittenInit())
+    Record.AddStmt(E->getRewrittenExpr());
   Code = serialization::EXPR_CXX_DEFAULT_INIT;
 }
 
 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
   Record.AddCXXTemporary(E->getTemporary());
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_CXX_BIND_TEMPORARY;

clang/test/AST/ast-dump-records.cpp

struct Derived5 : protected virtual Base1 {
   // CHECK: virtual protected 'Base1'
 };
 
 template <typename... Bases>
 struct Derived6 : virtual public Bases... {
   // CHECK: CXXRecordDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:[[@LINE+2]]:1> line:[[@LINE-1]]:8 struct Derived6 definition
   // CHECK: virtual public 'Bases'...
 };
+
+class NonTrivial {
+// CHECK: |-CXXRecordDecl {{.*}} referenced class NonTrivial definition
+ public:
+  NonTrivial();
+// CHECK: | |-CXXConstructorDecl {{.*}} referenced NonTrivial 'void ()'
+  ~NonTrivial();
+// CHECK: | |-CXXDestructorDecl {{.*}} referenced ~NonTrivial 'void () noexcept'
+};
+
+struct CheckFullExpression {
+// CHECK: |-CXXRecordDecl {{.*}} struct CheckFullExpression definition
+  NonTrivial value = NonTrivial();
+// CHECK: | |-FieldDecl {{.*}} value 'NonTrivial':'NonTrivial'
+// CHECK-NEXT: | | `-ExprWithCleanups {{.*}} 'NonTrivial':'NonTrivial'
+// CHECK-NEXT: | |   `-CXXBindTemporaryExpr {{.*}} 'NonTrivial':'NonTrivial' (CXXTemporary{{.*}})
+// CHECK-NEXT: | |     `-CXXTemporaryObjectExpr {{.*}} 'NonTrivial':'NonTrivial' 'void ()'
+};
+
+struct CheckNoCleanup {
+// CHECK: `-CXXRecordDecl {{.*}} struct CheckNoCleanup definition
+  static constexpr char kConstant = '+';
+// CHECK: `-VarDecl {{.*}} kConstant 'const char' static inline constexpr cinit
+// CHECK-NEXT: |-value: Int 43
+// CHECK-NEXT: `-CharacterLiteral {{.*}} 'char' 43
+};

clang/test/CXX/class/class.local/p1-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 
 
 void f() {
   int x = 3; // expected-note{{'x' declared here}}
   const int c = 2;
   struct C {
     int& x2 = x; // expected-error{{reference to local variable 'x' declared in enclosing function 'f'}}
     int cc = c;
   };
   (void)[]() mutable {
     int x = 3; // expected-note{{'x' declared here}}
     struct C {
       int& x2 = x; // expected-error{{reference to local variable 'x' declared in enclosing lambda expression}}
-    };
-  };
-  C();
+    }c; // expected-note {{required here}}
+  C(); // expected-note {{required here}}
 }
 

clang/test/CXX/drs/dr26xx.cpp

 void f() {
     int neck, tail;
     volatile int brachiosaur;
     brachiosaur += neck;                // OK
     brachiosaur -= neck;                // OK
     brachiosaur |= neck;                // OK
 }
 }
+
+namespace dr2631 { // dr2631: 16
+  constexpr int g();
+  consteval int f() {
+    return g();
+  }
+  int k(int x = f()) {
+    return x;
+  }
+  constexpr int g() {
+    return 42;
+  }
+  int test() {
+    return k();
+  }
+}

clang/test/CodeGenCXX/builtin-source-location.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -std=c++2a -fblocks %s -triple x86_64-unknown-unknown -emit-llvm -o %t.ll
+// RUN: %clang_cc1 -no-opaque-pointers -std=c++14 -fblocks %s -triple x86_64-unknown-unknown -emit-llvm -o %t.ll
+
 
 // This needs to be performed before #line directives which alter filename
 // RUN: %clang_cc1 -no-opaque-pointers -fno-file-reproducible -fmacro-prefix-map=%p=/UNLIKELY/PATH -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-PREFIX-MAP
 //
 // CHECK-PREFIX-MAP: /UNLIKELY/PATH{{/|\\\\}}builtin-source-location.cpp
 void testRemap() {
   const char *file = __builtin_FILE();
 }

clang/test/CodeGenCXX/default-arguments-with-immediate.cpp

+// RUN: %clang_cc1 -std=c++2a -triple x86_64-elf-gnu %s -emit-llvm -o - | FileCheck %s
+
+consteval int immediate() { return 0;}
+static int ext();
+void f(int a = immediate() + ext());
+
+void test_function() {
+    f();
+    f(0);
+    // CHECK: call noundef i32 @_ZL3extv()
+    // CHECK: add
+    // CHECK: call {{.*}} @_Z1fi
+    // CHECK: call {{.*}} @_Z1fi
+}
+
+// CHECK: define {{.*}} i32 @_ZL3extv()
+
+static constexpr int not_immediate();
+struct A {
+    int a = immediate() + not_immediate();
+};
+
+void test_member() {
+    // CHECK: call void @_ZN1AC2Ev
+    A defaulted;
+    // CHECK-NOT: call void @_ZN1AC2Ev
+    A provided{0};
+}
+
+// CHECK: define {{.*}} void @_ZN1AC2Ev{{.*}}
+// CHECK: %call = call noundef i32 @_ZL13not_immediatev()
+
+int never_referenced() {return 42;};
+
+
+namespace not_used {
+
+struct A {
+    int a = immediate() + never_referenced();
+};
+void f(int a = immediate() + never_referenced());
+
+void g() {
+    A a{0};
+    f(0);
+}
+
+}
+
+static int ext() {return 0;}
+static constexpr int not_immediate() {return 0;}
+
+// CHECK-NOT: define {{.*}} i32 _ZL16never_referencedv()(
+// CHECK: define {{.*}} i32 @_ZL13not_immediatev()

clang/test/CodeGenCXX/meminit-initializers-odr.cpp

+// RUN: %clang_cc1 -std=c++20 %s -triple x86_64-linux-gnu -emit-llvm -o - | FileCheck %s
+
+struct ThisShouldBeCalled {
+    ThisShouldBeCalled() {}
+};
+
+template <typename T>
+struct ThisShouldBeCalledTPL {
+    ThisShouldBeCalledTPL() {}
+};
+
+consteval int f () {
+    return 42;
+}
+
+struct WithConsteval {
+    WithConsteval(int x = f()) {}
+};
+
+template <typename T>
+struct WithConstevalTPL {
+    WithConstevalTPL(T x = f()) {}
+};
+
+
+struct Base {
+    ThisShouldBeCalled y = {};
+};
+
+struct S : Base {
+    ThisShouldBeCalledTPL<int> A =  {};
+    WithConsteval B = {};
+    WithConstevalTPL<double> C = {};
+};
+void Do(S = S{}) {}
+
+void test() {
+    Do();
+}
+
+// CHECK-LABEL: @_ZN18ThisShouldBeCalledC2Ev
+// CHECK-LABEL: @_ZN21ThisShouldBeCalledTPLIiEC2Ev
+// CHECK-LABEL: @_ZN13WithConstevalC2Ei
+// CHECK-LABEL: @_ZN16WithConstevalTPLIdEC2Ed
+
+namespace check_arrays {
+
+template <typename T>
+struct inner {
+    inner() {}
+};
+
+struct S {
+   inner<int> a {};
+};
+
+class C {
+    S s[1]{};
+};
+
+int f() {
+    C c;
+    return 0;
+}
+
+// CHECK-LABEL: @_ZN12check_arrays5innerIiEC2Ev
+
+}
+
+namespace check_field_inits_in_base_constructors {
+
+template <typename>
+struct ShouldBeODRUsed {
+  ShouldBeODRUsed() {}
+};
+class k {
+// The private here is important,
+// otherwise it would be aggregate initialized.
+private:
+  ShouldBeODRUsed<k> a = {};
+};
+
+struct b {
+  k c{};
+};
+void test() { b d; }
+
+// CHECK-LABEL: @_ZN38check_field_inits_in_base_constructors15ShouldBeODRUsedINS_1kEEC2Ev
+
+}
+
+namespace check_referenced_when_defined_in_default_parameter {
+
+template <typename T>
+struct Test {
+    Test(auto&&) {}
+};
+
+struct Options {
+    Test<bool(bool x)> identity = [](bool x) -> bool { return x; };
+};
+
+struct Wrapper {
+  Wrapper(const Options& options = Options());
+};
+
+void Func() { Options options; }
+
+// CHECK-LABEL: @_ZN50check_referenced_when_defined_in_default_parameter7OptionsC2Ev
+// CHECK-LABEL: @_ZN50check_referenced_when_defined_in_default_parameter4TestIFbbEEC1INS_7Options8identityMUlbE_EEEOT_
+// CHECK-LABEL: @_ZN50check_referenced_when_defined_in_default_parameter4TestIFbbEEC2INS_7Options8identityMUlbE_EEEOT_
+
+}
+
+namespace lambda_body {
+template <typename a>
+int templated_func() {
+    return 0;
+}
+struct test_body {
+  int mem = templated_func<int>();
+};
+struct test_capture {
+  int mem = templated_func<double>();
+};
+
+struct S {
+  int a = [_ = test_capture{}] { (void)test_body{}; return 0;}();
+};
+
+void test() {
+    S s;
+}
+
+// CHECK-LABEL: define{{.*}} @_ZN11lambda_body14templated_funcIdEEiv
+// CHECK-LABEL: define{{.*}} @_ZNK11lambda_body1S1aMUlvE_clEv
+// CHECK-LABEL: define{{.*}} @_ZN11lambda_body14templated_funcIiEEiv
+
+
+}

clang/test/PCH/default-argument-with-immediate-calls.cpp

+// RUN: %clang_cc1 -std=c++20 -emit-pch %s -o %t
+// RUN: %clang_cc1 -std=c++20 -include-pch %t -verify %s
+// expected-no-diagnostics
+
+#ifndef HEADER_INCLUDED
+#define HEADER_INCLUDED
+
+consteval int immediate();
+int regular_function() {
+    return 0;
+}
+
+struct S {
+  int a = immediate() + regular_function();
+};
+
+int f(int arg = immediate()) {
+    return arg;
+}
+
+#else
+
+consteval int immediate() {
+    return 0;
+}
+
+void test() {
+    f(0);
+    f();
+    S s{0};
+    S t{0};
+}
+
+#endif

clang/test/SemaCXX/cxx11-default-member-initializers.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -pedantic
+// RUN: %clang_cc1 -std=c++20 -verify %s -pedantic
+
 
 namespace PR31692 {
   struct A {
     struct X { int n = 0; } x;
     // Trigger construction of X() from a SFINAE context. This must not mark
     // any part of X as invalid.
     static_assert(!__is_constructible(X), "");
     // Check that X::n is not marked invalid.
     double &r = x.n; // expected-error {{non-const lvalue reference to type 'double' cannot bind to a value of unrelated type 'int'}}
   };
   // A::X can now be default-constructed.
   static_assert(__is_constructible(A::X), "");
 }
+
+
+struct S {
+} constexpr s;
+struct C {
+  C(S);
+};
+class MemInit {
+  C m = s;
+};
+
+#if __cplusplus >= 202002L
+// This test ensures cleanup expressions are correctly produced
+// in the presence of default member initializers.
+namespace PR136554 {
+struct string {
+  constexpr string(const char*) {};
+  constexpr ~string();
+};
+struct S;
+struct optional {
+    template <typename U = S>
+    constexpr optional(U &&) {}
+};
+struct S {
+    string a;
+    optional b;
+    int defaulted = 0;
+} test {
+    "", {
+        { "", 0 }
+    }
+};
+
+// Ensure that the this pointer is
+// transformed without crashing
+consteval int immediate() { return 0;}
+struct StructWithThisInInitializer {
+  int member() const {
+      return 0;
+  }
+  int m = member() + immediate();
+  int m2 = this->member() + immediate();
+};
+
+template <typename T>
+struct StructWithThisInInitializerTPL {
+  template <typename U>
+  int member() const {
+      return 0;
+  }
+  int m = member<int>() + immediate();
+  int m2 = this->member<int>() + immediate();
+};
+
+void test_this() {
+  (void)StructWithThisInInitializer{};
+  (void)StructWithThisInInitializerTPL<int>{};
+}
+
+struct ReferenceToNestedMembers {
+  int m;
+  int a = ((void)immediate(), m); // ensure g is found in the correct scope
+  int b = ((void)immediate(), this->m); // ensure g is found in the correct scope
+};
+struct ReferenceToNestedMembersTest {
+ void* m = nullptr;
+ ReferenceToNestedMembers j{0};
+} test_reference_to_nested_members;
+
+}
+
+
+namespace odr_in_unevaluated_context {
+template <typename e, bool = __is_constructible(e)> struct f {
+    using type = bool;
+};
+
+template <class k, f<k>::type = false> int l;
+int m;
+struct p {
+  // This used to crash because m is first marked odr used
+  // during parsing, but subsequently used in an unevaluated context
+  // without being transformed.
+  int o = m;
+  p() {}
+};
+
+int i = l<p>;
+}
+
+#endif

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2b %s
+
+consteval int undefined();  // expected-note 4 {{declared here}}
+
+void check_lambdas_unused(
+    int a = []
+    {
+        // The body of a lambda is not a subexpression of the lambda
+        // so this is immediately evaluated even if the parameter
+        // is never used.
+        return undefined();  // expected-error {{not a constant expression}} \
+                             // expected-note  {{undefined function 'undefined'}}
+    }(),
+    int b = [](int no_error = undefined()) {
+        return no_error;
+    }(0),
+    int c = [](int defaulted = undefined()) {
+        return defaulted;
+    }()
+) {}
+
+int check_lambdas_used(
+    int b = [](int no_error = undefined()) {
+        return no_error;
+    }(0),
+    int c = [](int defaulted = undefined()) { // expected-error {{not a constant expression}} \
+                              // expected-note  {{declared here}} \
+                              // expected-note  {{undefined function 'undefined'}}
+        return defaulted;
+    }(),  // expected-note {{in the default initalizer of 'defaulted'}}
+    int d = [](int defaulted = sizeof(undefined())) {
+        return defaulted;
+    }()
+) {
+    return 0;
+}
+
+int test_check_lambdas_used = check_lambdas_used();
+
+struct UnusedInitWithLambda {
+    int a = [] {
+        return undefined();  // expected-error {{not a constant expression}} \
+                             // expected-note  {{undefined function 'undefined'}}
+    }();
+    // UnusedInitWithLambda is never constructed, so the initializer
+    // of b and undefined() are never evaluated.
+    int b = [](int no_error = undefined()) {
+        return no_error;
+    }();
+};
+
+consteval int ub(int n) {
+    return 0/n; // expected-note  {{division}}
+}
+
+struct InitWithLambda {
+    int b = [](int error = undefined()) { // expected-error {{not a constant expression}} \
+                              // expected-note  {{declared here}} \
+                              // expected-note  {{undefined function 'undefined'}}
+        return error;
+    }(); // expected-note {{in the default initalizer of 'error'}}
+    int c = [](int error = sizeof(undefined()) + ub(0)) { // expected-error {{'ub' is not a constant expression}} \
+                                                          // expected-note  {{declared here}} \
+                                                          // expected-note {{in call to 'ub(0)}}
+        return error;
+    }(); // expected-note {{in the default initalizer of 'error'}}
+} i; // expected-note {{in implicit default constructor}}
+
+namespace ShouldNotCrash {
+    template<typename T>
+    struct F {
+        template<typename U>
+        F(const U&) {}
+    };
+    struct A {
+        static constexpr auto x = [] {};
+        F<int> f = x;
+    };
+    void f(A a = A()) { }
+}

clang/test/SemaCXX/source_location.cpp

 // RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fexceptions -verify %s
+// RUN: %clang_cc1 -std=c++2a -fcxx-exceptions -DUSE_CONSTEVAL -fexceptions -verify %s
 // expected-no-diagnostics
 
 #define assert(...) ((__VA_ARGS__) ? ((void)0) : throw 42)
 #define CURRENT_FROM_MACRO() SL::current()
 #define FORWARD(...) __VA_ARGS__
 
 template <unsigned>
 struct Printer;
 
+#ifdef USE_CONSTEVAL
+#define SOURCE_LOC_EVAL_KIND consteval
+#else
+#define SOURCE_LOC_EVAL_KIND constexpr
+#endif
+
 namespace std {
 class source_location {
   struct __impl;
 
 public:
-  static constexpr source_location current(const __impl *__p = __builtin_source_location()) noexcept {
+  static SOURCE_LOC_EVAL_KIND source_location
+    current(const __impl *__p = __builtin_source_location()) noexcept {
       source_location __loc;
       __loc.__m_impl = __p;
       return __loc;
   }
   constexpr source_location() = default;
   constexpr source_location(source_location const &) = default;
   constexpr unsigned int line() const noexcept { return __m_impl ? __m_impl->_M_line : 0; }
   constexpr unsigned int column() const noexcept { return __m_impl ? __m_impl->_M_column : 0; }
   constexpr const char *file() const noexcept { return __m_impl ? __m_impl->_M_file_name : ""; }
   constexpr const char *function() const noexcept { return __m_impl ? __m_impl->_M_function_name : ""; }
 

 #line 7100 "Bar.cpp"
   constexpr const char* bar(const char* x = foo()) { return x; }
   constexpr bool test() {
     static_assert(is_equal(bar(), "TestConstexprContext.cpp"));
     return true;
   }
   static_assert(test());
 }
+
+namespace Lambda {
+#line 8000 "TestLambda.cpp"
+constexpr int nested_lambda(int l = []{
+  return SL::current().line();
+}()) {
+  return l;
+}
+static_assert(nested_lambda() == __LINE__ - 4);
+
+constexpr int lambda_param(int l = [](int l = SL::current().line()) {
+  return l;
+}()) {
+  return l;
+}
+static_assert(lambda_param() == __LINE__);
+
+
+}
+
+constexpr int compound_literal_fun(int a =
+                  (int){ SL::current().line() }
+) { return a ;}
+static_assert(compound_literal_fun() == __LINE__);
+
+struct CompoundLiteral {
+  int a = (int){ SL::current().line() };
+};
+static_assert(CompoundLiteral{}.a == __LINE__);
+
+
+// FIXME
+// Init captures are subexpressions of the lambda expression
+// so according to the standard immediate invocations in init captures
+// should be evaluated at the call site.
+// However Clang does not yet implement this as it would introduce
+// a fair bit of complexity.
+// We intend to implement that functionality once we find real world
+// use cases that require it.
+constexpr int test_init_capture(int a =
+                [b = SL::current().line()] { return b; }()) {
+  return a;
+}
+#ifdef USE_CONSTEVAL
+static_assert(test_init_capture() == __LINE__ - 4);
+#else
+static_assert(test_init_capture() == __LINE__ );
+#endif
+
+namespace check_immediate_invocations_in_templates {
+
+template <typename T = int>
+struct G {
+    T line = __builtin_LINE();
+};
+template <typename T>
+struct S {
+    int i = G<T>{}.line;
+};
+static_assert(S<int>{}.i != // intentional new line
+              S<int>{}.i);
+
+template <typename T>
+constexpr int f(int i = G<T>{}.line) {
+    return i;
+}
+
+static_assert(f<int>() != // intentional new line
+              f<int>());
+}

clang/www/cxx_dr_status.html

<tr id="2630">
     <td>DR</td>
     <td>Syntactic specification of class completeness</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2631">
     <td><a href="https://wg21.link/cwg2631">2631</a></td>
     <td>DR</td>
     <td>Immediate function evaluations in default arguments</td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 16</td>
   </tr>
   <tr class="open" id="2632">
     <td><a href="https://wg21.link/cwg2632">2632</a></td>
     <td>open</td>
     <td>'user-declared' is not defined</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2633">