[clang][C++20] P0960R3 and P1975R0: Allow initializing aggregates from a parenthesized list of values

[ayzhao]

Summary

This patch implements P0960R3, which allows initialization of aggregates
via parentheses.

As an example:

struct S { int i, j; };
S s1(1, 1);

int arr1[2](1, 2);

This patch also implements P1975R0, which fixes the wording of P0960R3
for single-argument parenthesized lists so that statements like the
following are allowed:

S s2(1);
S s3 = static_cast<S>(1);
S s4 = (S)1;

int (&&arr2)[] = static_cast<int[]>(1);
int (&&arr3)[2] = static_cast<int[2]>(1);

This patch was originally authored by @0x59616e and completed by
@ayzhao.

Fixes #54040, Fixes #54041

Co-authored-by: Sheng <[e-mail]>

Full write up : https://discourse.llvm.org/t/c-20-rfc-suggestion-desired-regarding-the-implementation-of-p0960r3/63744

[shafik]

clang/include/clang/AST/ExprCXX.h

4779

Should we prefer makeArrayRef?

clang/lib/CodeGen/CGExprAgg.cpp

1618

clang/lib/Sema/SemaInit.cpp

5263

I feel like this function could use a lot of comments, I found it hard to follow the flow of logic and I think I get it mostly now but comments would have helped a lot.

5273

Or some other clarifying comment.

5310

[ayzhao]

In D129531#3873872, @royjacobson wrote:

Thanks for working on it! It looks really good. Please remember to update the feature test macro (__cpp_aggregate_paren_init).

Done

Also, I think there's no test coverage for the ASTReader/Writer changes? I would like to see some as well.

I added a precompiled header test. Currently, the ASTReader/Writer change is broken with the following error:

                                                                                                                         "hunter-bidens-laptop." 15:58 24-Oct-22
$ bin/llvm-lit -vv --debug ../clang/test/PCH/cxx_paren_init.cpp
[553/553] Creating executable symlink bin/clang
llvm-lit: /llvm-project/llvm/utils/lit/lit/discovery.py:62: note: loading suite config '/llvm-project/build/tools/clang/test/lit.site.cfg.py'
llvm-lit: /llvm-project/llvm/utils/lit/lit/LitConfig.py:116: note: load_config from '/llvm-project/clang/test/lit.cfg.py'
llvm-lit: /llvm-project/llvm/utils/lit/lit/llvm/config.py:456: note: using clang: /llvm-project/build/bin/clang
llvm-lit: /llvm-project/llvm/utils/lit/lit/TestingConfig.py:129: note: ... loaded config '/llvm-project/clang/test/lit.cfg.py'
llvm-lit: /llvm-project/llvm/utils/lit/lit/TestingConfig.py:129: note: ... loaded config '/llvm-project/build/tools/clang/test/lit.site.cfg.py'
llvm-lit: /llvm-project/llvm/utils/lit/lit/discovery.py:136: note: resolved input '../clang/test/PCH/cxx_paren_init.cpp' to 'Clang'::('PCH', 'cxx_paren_init.cpp')
-- Testing: 1 tests, 1 workers --
FAIL: Clang :: PCH/cxx_paren_init.cpp (1 of 1)
******************** TEST 'Clang :: PCH/cxx_paren_init.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /llvm-project/build/bin/clang -cc1 -internal-isystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -emit-pc
h -o /llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.tmp /llvm-project/clang/test/PCH/cxx_paren_init.h
: 'RUN: at line 2';   /llvm-project/build/bin/clang -cc1 -internal-isystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -include
-pch /llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.tmp -fsyntax-only -S -o -
--
Exit Code: 139

Command Output (stderr):
--
+ : 'RUN: at line 1'
+ /llvm-project/build/bin/clang -cc1 -internal-isystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -emit-pch -o /dev/shm/ayzhao
_llvm/llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.tmp /llvm-project/clang/test/PCH/cxx_paren_init.h
+ : 'RUN: at line 2'
+ /llvm-project/build/bin/clang -cc1 -internal-isystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -include-pch /dev/shm/ayzhao
_llvm/llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.tmp -fsyntax-only -S -o -
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: /llvm-project/build/bin/clang -cc1 -internal-isystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -in
clude-pch /llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.tmp -fsyntax-only -S -o -
1.      <eof> parser at end of file
2.      /llvm-project/clang/test/PCH/cxx_paren_init.h:4:3: LLVM IR generation of declaration 'foo'
3.      /llvm-project/clang/test/PCH/cxx_paren_init.h:4:3: Generating code for declaration 'foo'
 #0 0x000055ac3d88eeea llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /src/llvm_tmpfs/llvm-project/llvm/lib/Support/Unix/Signals.inc:569:11
 #1 0x000055ac3d88f09b PrintStackTraceSignalHandler(void*) /src/llvm_tmpfs/llvm-project/llvm/lib/Support/Unix/Signals.inc:636:1
 #2 0x000055ac3d88d6e6 llvm::sys::RunSignalHandlers() /src/llvm_tmpfs/llvm-project/llvm/lib/Support/Signals.cpp:104:5
 #3 0x000055ac3d88f7c5 SignalHandler(int) /src/llvm_tmpfs/llvm-project/llvm/lib/Support/Unix/Signals.inc:407:1
 #4 0x00007fbe3c83daf0 (/lib/x86_64-linux-gnu/libc.so.6+0x3daf0)
 #5 0x000055ac3dd9e32c clang::Stmt::getStmtClass() const /src/llvm_tmpfs/llvm-project/clang/include/clang/AST/Stmt.h:1166:44
 #6 0x000055ac3e40c735 clang::ImplicitValueInitExpr::classof(clang::Stmt const*) /src/llvm_tmpfs/llvm-project/clang/include/clang/AST/Expr.h:5527:30
 #7 0x000055ac3e40c715 llvm::isa_impl<clang::ImplicitValueInitExpr, clang::Expr, void>::doit(clang::Expr const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:64:46
 #8 0x000055ac3e40c6f3 llvm::isa_impl_cl<clang::ImplicitValueInitExpr, clang::Expr const*>::doit(clang::Expr const*) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:110:5
 #9 0x000055ac3e40c678 llvm::isa_impl_wrap<clang::ImplicitValueInitExpr, clang::Expr const*, clang::Expr const*>::doit(clang::Expr const* const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:137:5
#10 0x000055ac3e40c652 llvm::isa_impl_wrap<clang::ImplicitValueInitExpr, clang::Expr const* const, clang::Expr const*>::doit(clang::Expr const* const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:127:5
#11 0x000055ac3e40c625 llvm::CastIsPossible<clang::ImplicitValueInitExpr, clang::Expr const*, void>::isPossible(clang::Expr const* const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:255:5
#12 0x000055ac3e40d3d2 llvm::CastInfo<clang::ImplicitValueInitExpr, clang::Expr* const, void>::isPossible(clang::Expr* const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:510:5
#13 0x000055ac3e40d385 bool llvm::isa<clang::ImplicitValueInitExpr, clang::Expr*>(clang::Expr* const&) /src/llvm_tmpfs/llvm-project/llvm/include/llvm/Support/Casting.h:549:3
#14 0x000055ac3e4088ac (anonymous namespace)::AggExprEmitter::EmitInitializationToLValue(clang::Expr*, clang::CodeGen::LValue) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:1536:44
#15 0x000055ac3e402d1e (anonymous namespace)::AggExprEmitter::VisitCXXParenListInitExpr(clang::CXXParenListInitExpr*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:1628:5
#16 0x000055ac3e3fe04d clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*) /src/llvm_tmpfs/llvm-project/build/tools/clang/include/clang/AST/StmtNodes.inc:877:1
#17 0x000055ac3e3fba35 (anonymous namespace)::AggExprEmitter::Visit(clang::Expr*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:108:3
#18 0x000055ac3e40a9ed (anonymous namespace)::AggExprEmitter::VisitCastExpr(clang::CastExpr*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:864:5
#19 0x000055ac3e40992d clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::AggExprEmitter, void>::VisitExplicitCastExpr(clang::ExplicitCastExpr*) /src/llvm_tmpfs/llvm-project/build/tools/clang/include/clang/AST/StmtNodes.inc:973:1
#20 0x000055ac3e403c1d clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::AggExprEmitter, void>::VisitCXXFunctionalCastExpr(clang::CXXFunctionalCastExpr*) /src/llvm_tmpfs/llvm-project/build/tools/clang/include/clang/AST/StmtNodes.inc:989:1
#21 0x000055ac3e3fe17f clang::StmtVisitorBase<std::add_pointer, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*) /src/llvm_tmpfs/llvm-project/build/tools/clang/include/clang/AST/StmtNodes.inc:989:1
#22 0x000055ac3e3fba35 (anonymous namespace)::AggExprEmitter::Visit(clang::Expr*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:108:3
#23 0x000055ac3e3fb655 clang::CodeGen::CodeGenFunction::EmitAggExpr(clang::Expr const*, clang::CodeGen::AggValueSlot) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGExprAgg.cpp:2046:1
#24 0x000055ac3dfab89b clang::CodeGen::CodeGenFunction::EmitReturnStmt(clang::ReturnStmt const&) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGStmt.cpp:0:7
#25 0x000055ac3dfa8491 clang::CodeGen::CodeGenFunction::EmitStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGStmt.cpp:153:75
#26 0x000055ac3dfb1e5f clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(clang::CompoundStmt const&, bool, clang::CodeGen::AggValueSlot) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CGStmt.cpp:496:3
#27 0x000055ac3df8295d clang::CodeGen::CodeGenFunction::EmitFunctionBody(clang::Stmt const*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenFunction.cpp:1239:5
#28 0x000055ac3df83732 clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl, llvm::Function*, clang::CodeGen::CGFunctionInfo const&) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenFunction.cpp:1448:3
#29 0x000055ac3de1cd02 clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl, llvm::GlobalValue*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenModule.cpp:5321:3
#30 0x000055ac3de13639 clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl, llvm::GlobalValue*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenModule.cpp:3596:12
#31 0x000055ac3de18b3a clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenModule.cpp:3337:5
#32 0x000055ac3de11d50 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenModule.cpp:6180:5
#33 0x000055ac3ef4e7b0 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/ModuleBuilder.cpp:188:73
#34 0x000055ac3ef470e0 clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:232:12
#35 0x000055ac3ef4724b clang::BackendConsumer::HandleInterestingDecl(clang::DeclGroupRef) /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:260:5
#36 0x000055ac3f013cc3 clang::ASTReader::PassInterestingDeclToConsumer(clang::Decl*) /src/llvm_tmpfs/llvm-project/clang/lib/Serialization/ASTReader.cpp:7740:1
#37 0x000055ac3f0ebeba clang::ASTReader::PassInterestingDeclsToConsumer() /src/llvm_tmpfs/llvm-project/clang/lib/Serialization/ASTReaderDecl.cpp:3965:3
#38 0x000055ac3f013e27 clang::ASTReader::StartTranslationUnit(clang::ASTConsumer*) /src/llvm_tmpfs/llvm-project/clang/lib/Serialization/ASTReader.cpp:0:5
#39 0x000055ac417efb74 clang::ParseAST(clang::Sema&, bool, bool) /src/llvm_tmpfs/llvm-project/clang/lib/Parse/ParseAST.cpp:151:20
#40 0x000055ac3ed606ac clang::ASTFrontendAction::ExecuteAction() /src/llvm_tmpfs/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1164:1
#41 0x000055ac3ef432f4 clang::CodeGenAction::ExecuteAction() /src/llvm_tmpfs/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:1145:5
#42 0x000055ac3ed600ac clang::FrontendAction::Execute() /src/llvm_tmpfs/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1059:7
#43 0x000055ac3ec8f16c clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /src/llvm_tmpfs/llvm-project/clang/lib/Frontend/CompilerInstance.cpp:1043:23
#44 0x000055ac3ef2c007 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /src/llvm_tmpfs/llvm-project/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:266:8
#45 0x000055ac3b82a5e0 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /src/llvm_tmpfs/llvm-project/clang/tools/driver/cc1_main.cpp:250:13
#46 0x000055ac3b81c49c ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /src/llvm_tmpfs/llvm-project/clang/tools/driver/driver.cpp:316:5
#47 0x000055ac3b81b325 clang_main(int, char**) /src/llvm_tmpfs/llvm-project/clang/tools/driver/driver.cpp:388:5
#48 0x000055ac3b84a8b2 main /src/llvm_tmpfs/llvm-project/build/tools/clang/tools/driver/clang-driver.cpp:11:35
#49 0x00007fbe3c82920a __libc_start_call_main ./csu/../sysdeps/nptl/libc_start_call_main.h:58:16
#50 0x00007fbe3c8292bc call_init ./csu/../csu/libc-start.c:128:20
#51 0x00007fbe3c8292bc __libc_start_main ./csu/../csu/libc-start.c:376:5
#52 0x000055ac3b81aba1 _start (/llvm-project/build/bin/clang+0x54d9ba1)
/llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.cpp.script: line 2: 1747518 Segmentation fault      /llvm-project/build/bin/clang -cc1 -internal-is
ystem /llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -x c++ -std=c++20 -include-pch /llvm-project/build/tools/clang/test/PCH/Output/cxx_paren_init.c
pp.tmp -fsyntax-only -S -o -

--

********************
********************
Failed Tests (1):
  Clang :: PCH/cxx_paren_init.cpp


Testing Time: 48.40s
  Failed: 1

I'm currently looking into this - I suspect it has to do with CXXParenListInitExpr storing all it's subexpressions in an llvm::TrailingObjects base class, but I have yet to confirm one way or another.

[ayzhao]

some comment fixes, add a test for serialization which doesn't work yet

[ayzhao]

remove whitespace change and disable test

[ilya-biryukov]

clang/lib/Serialization/ASTReaderStmt.cpp

2179

FYI: I think this is where the crash comes from.
We should allocate the trailing objects first.
E.g. see how PragmaCommentDecl::CreateDeserialized does this.

[ayzhao]

clang/lib/Serialization/ASTReaderStmt.cpp

2179

This sounds like it could be the solution - thanks for looking at it!

Currently, I'm working on the refactor that shafik@ suggested, which was to inherit from InitListExpr. Hopefully, that refactor will fix this issue as InitListExpr stores it's subexpressions in a class member instead of using llvm::TrailingObjects.

[ilya-biryukov]

clang/lib/Serialization/ASTReaderStmt.cpp

2179

Are we trying to share code between two implementations? If so, I suggest to consider alternatives, e.g. creating a new base class and inheriting both InitListExpr and CXXParentInitListExpr to share the common code.

Inheriting CXXParentInitListExpr from InitListExpr breaks Liskov substitution principle and will likely to lead to bugs that are hard to chase. InitListExpr is widely used and means`{}. CXXParenInitListExpr` is not {} and we do not know in advance which code is going to work for both and which code is only valid for {}. Reviewing all callsites that use InitListExpr does not seem plausible. Note that in addition to Clang, there are also uses in ast-matchers and in clang-tidy checks (quite a few of those are downstream).

[ayzhao]

Fix PCH test and address some code review comments

[ayzhao]

In D129531#3880875, @ayzhao wrote:

In D129531#3873872, @royjacobson wrote:

Thanks for working on it! It looks really good. Please remember to update the feature test macro (__cpp_aggregate_paren_init).

Done

Also, I think there's no test coverage for the ASTReader/Writer changes? I would like to see some as well.

I added a precompiled header test. Currently, the ASTReader/Writer change is broken with the following error:

...

I'm currently looking into this - I suspect it has to do with CXXParenListInitExpr storing all it's subexpressions in an llvm::TrailingObjects base class, but I have yet to confirm one way or another.

The PCH test is fixed now, so we now have coverage for the ASTReader/Writer changes.

clang/lib/AST/Expr.cpp

3773

See the response from @ilya-biryukov for why I decided against inheriting from InitListExpr.

clang/lib/AST/ExprClassification.cpp

446

IMO; no.

I believe the comment for InitListExpr refers to statements like:

int a;
int &b{a};

This doesn't apply to CXXParenListInitExprClass because the corresponding statement with parentheses wouldn't be parsed as a CXXParenListInitExpr in the first place.

clang/lib/AST/StmtPrinter.cpp

2464

See the response from @ilya-biryukov for why I decided against inheriting from InitListExpr.

clang/lib/Sema/TreeTransform.h

13917

This is an extra change, but clang-format would always make it.

clang/lib/Serialization/ASTReaderStmt.cpp

2179

So I figured out why this was failing. When I created the CXXParenListInitExpr object on the heap in ASTReader::ReadStmtFromStream(...) below, I just called new without allocating any space for the TrailingObjects. This is fixed now, and the PCH test passes.

Inheriting CXXParentInitListExpr from InitListExpr breaks Liskov substitution principle and will likely to lead to bugs that are hard to chase. InitListExpr is widely used and means`{}. CXXParenInitListExpr` is not {} and we do not know in advance which code is going to work for both and which code is only valid for {}. Reviewing all callsites that use InitListExpr does not seem plausible. Note that in addition to Clang, there are also uses in ast-matchers and in clang-tidy checks (quite a few of those are downstream).

+1, I am convinced that inheriting from InitListExpr is the wrong thing to do here. Additionally, when I tried to inherit from InitListExpr, I found that there were a lot of things in that class that were specific to InitListExpr that I had to wrap with an if statement to make it work with CXXParenListInitExpr, and that the amount of code that I had to add considerably decreases readability.

[ayzhao]

we don't need CHECK-DAG here

[ayzhao]

add C++20 extension diagnostics and some other code review feedback

[ayzhao]

Friendly ping for reviewers as all comments should be addressed by now.

In D129531#3873775, @cor3ntin wrote:

It starting to look great.
Should we add an extension warning? Note that I'm not suggesting to support that in earlier modes, just an off-by-default warning that says "this is a c++20 feature". but we are a bit inconsistent with those.

Done

can you rename test/SemaCXX/P0960R3.cpp to something like test/SemaCXX/cxx20-paren-list-init.cpp (and same for other tests?) it's more consistent with other existing tests.

Done

clang/lib/Sema/SemaInit.cpp

5263

I added some comments, did a little refactoring, and renamed some variables. PTAL and LMKWYT.

[cor3ntin]

I added a few more comments, mostly nitpicks

clang/lib/AST/ExprConstant.cpp

9952–9953

9956

Maybe that message could be a bit more clear.

"Union should have exactly 1 initializer in in C++ paren list" or something like that.

clang/lib/CodeGen/CGExprAgg.cpp

1595

There are some overlaps with VisitInitListExpr, I wonder if we should try to factor out some of the code, especially the base class initialization

1600

Maybe it would be cleaner to use a structured binding here.

1616

Should we assert that the base is not virtual?

clang/lib/Sema/SemaInit.cpp

5282

clang/lib/Sema/TreeTransform.h

13925

ArgumentChanged is not used, and is defaulted by the function, so you should be able to remove it

[ayzhao]

address some comments and implement disallowing flexible array members

[ayzhao]

Status update:

While investigating @cor3ntin's comment about refactoring VisitInitListExpr and VisitCXXParenListInitExpr as they share common code, I discovered that flexible array members would cause this patch to explode. Specifically, the following code:

struct S {
    int b;
    int a[];
};

S s2(1, {1, 2});

was causing this assertion to fail.

I took a look at GCC, and it turns out that GCC doesn't allow flexible array members at all in paren list initialization of aggregates, even in contexts where the corresponding designated initializer expression succeeds: https://godbolt.org/z/E73433erb

For now, I updated this implementation to follow GCC's behavior and disallow flexible array members, as IIRC in C++ they are a GCC extension and we should therefore follow GCC behavior. However, I am open to other thoughts.

[ayzhao]

clang-format + rebase

[ayzhao]

Merge CXXParenListInitExpr with VisitInitListExpr, also friendly ping as all comments are addressed

[cor3ntin]

I think this is basically good to go, but I'll let other people give it a look too

clang/lib/AST/ExprConstant.cpp

9965–9968

clang/lib/CodeGen/CGExprAgg.cpp

92

Could you give E a better name?

478

Ditto

[ayzhao]

addressed code review comments

[ayzhao]

rebase + update commit message

[ayzhao]

Friendly ping, does anyone else have any more comments?

[ayzhao]

whoops, uploaded the wrong commit. should be fixed now

[ayzhao]

remove extra parens

[ayzhao]

s/pro20/post20/g

[cor3ntin]

There is a C++ standard meeting this week so some folks won't be able to review it. Feel free to re-ping next week if nobody else replies.
Because it's a fairly big change and I've been known to miss glaring things, I don't feel comfortable to approve it. But it looks great to me.
Either way we need to make sure this ships in Clang 16.

[shafik]

I am in the committee meeting this week but if you ping next week I should have time.

[ilya-biryukov]

Sorry for not reviewing this sooner. This looks very good overall, but I still have some NITs and a few major comments. For the major points see:

• the comment about the filler and the syntactic/semantic form for the newly added expression,
• the comment about relying on getFailedCandidateSet().size().

clang/lib/AST/ExprCXX.cpp

1769

NIT: add newline

clang/lib/AST/ExprConstant.cpp

9965

NIT: maybe add braces as the other branches have them? This seems to be in the style guide:

readability is also harmed if an if/else chain does not use braced bodies for either all or none of its members

10934

Could we add an assertion that the array size and the InitExprs.size() are the same?
E.g. it can differ in the case of InitListExpr (probably due to the filler optimization?), it would be nice to add a sanity check here.

clang/lib/AST/JSONNodeDumper.cpp

852

NIT: maybe use the same formatting as other switch cases for constistency?

clang/lib/CodeGen/CGExprAgg.cpp

478

NIT: maybe add a comment that ExprToVisit is either InitListExpr or CXXParenInitListExpr?

577

• Should we have a filler for CXXParenInitListExpr too? It seems like an important optimization and could have large effect on compile times if we don't

• Same question for semantic and syntactic-form (similar to InitListExpr): should we have it here? I am not sure if it's semantically required (probably not?), but that's definitely something that clang-tidy and other source tools will rely on.

We should probably share the code there, I suggest moving it to a shared base class and using it where appropriate instead of the derived classes.

clang/lib/Sema/SemaInit.cpp

6112

It seems shaky to rely on the size of getFailedCandidateSet.
What are we trying to achieve here? Is there a more direct way to specify it?

6131

NIT: maybe move the full comment into the body of the function?
It describes in detail what the body of the function does and it would be easier to understand whether the code fits the intention in the standard.
Having the first part of the comment here would still be useful, probably.

clang/lib/Serialization/ASTReaderStmt.cpp

2178

Could we assign the CXXParenInitListExpr.NumExprs on construction and add the assertion sanity-checking the numbers here:

unsigned NumExprs = Record.readInt();
(void)NumExprs; // to avoid unused warnings in NDEBUG builds.
assert(NumExprs == E->NumExprs);

(Looked up how DesignatedInitExpr does a similar thing, probably good for consistency in addition to added safety)

[ayzhao]

address code review comments

clang/lib/AST/JSONNodeDumper.cpp

852

Unfortunately clang-format insists that these be on separate lines.

clang/lib/CodeGen/CGExprAgg.cpp

577

Should we have a filler for CXXParenInitListExpr too? It seems like an important optimization and could have large effect on compile times if we don't

This feels like premature optimization - presumably, wouldn't this only be an issue with extraordinarily large (say, O(1000)) arrays?

Same question for semantic and syntactic-form (similar to InitListExpr): should we have it here? I am not sure if it's semantically required (probably not?), but that's definitely something that clang-tidy and other source tools will rely on

IIRC this doesn't apply to paren list aggregate expressions, as the syntatic form would be the enclosing ParenListExpr.

clang/lib/Sema/SemaInit.cpp

6112

Done.

As mentioned in the above comment, we try to parse this as a CXXParenListInit if the only failed overload constructor candidates are the default constructor, the default copy constructor, and the default move constructor).

6131

Done. Most of this comment is spread out throughout the body of the function anyways.

[ilya-biryukov]

Thanks for addressing the comments and sorry for a wait before the comments.
Please see the comment about syntactic form, I might be holding it wrong, but it looks like we actually loose the syntactic form completely in this case.

clang/lib/AST/JSONNodeDumper.cpp

852

Ah, that's unfortunate. I normally just revert the effect of clang-format for those lines, but up to you.
Also fine to keep as is or even format the other lines according to the style guide (it's just 3 more lines, so should not be a big deal).

clang/lib/CodeGen/CGExprAgg.cpp

577

This feels like premature optimization - presumably, wouldn't this only be an issue with extraordinarily large (say, O(1000)) arrays?

Yes, this should only happen with large arrays. Normally I would agree, but it's surprising that changing {} to () in the compiler would lead to performance degradation.
In that sense, this premature optimization is already implemented, we are rather degrading performance for a different syntax to do the same thing.

Although we could also land without it, but in that case could you open a GH issue and add a FIXME to track the implementation of this particular optimization?
This should increase the chances of users finding the root cause of the issue if they happen to hit it.

IIRC this doesn't apply to paren list aggregate expressions, as the syntatic form would be the enclosing ParenListExpr.

Do we even have the enclosing ParenListExpr? If I dump the AST with clang -fsyntax-only -Xclang=-ast-dump ... for the following code:

struct pair { int a; int b = 2; };
int main() {
  pair(1); pair p(1);
  pair b{1}; pair{1};
}

I get

`-FunctionDecl 0x557d79717e98 <line:2:1, line:5:1> line:2:5 main 'int ()'
  `-CompoundStmt 0x557d797369d0 <col:12, line:5:1>
    |-CXXFunctionalCastExpr 0x557d79718528 <line:3:3, col:9> 'pair':'pair' functional cast to pair <NoOp>
    | `-CXXParenListInitExpr 0x557d79718500 <col:3> 'pair':'pair'
    |   |-IntegerLiteral 0x557d79718010 <col:8> 'int' 1
    |   `-IntegerLiteral 0x557d79717e18 <line:1:30> 'int' 2
    |-DeclStmt 0x557d79718650 <line:3:12, col:21>
    | `-VarDecl 0x557d79718568 <col:12, col:17> col:17 p 'pair':'pair' parenlistinit
    |   `-CXXParenListInitExpr 0x557d79718610 <col:17> 'pair':'pair'
    |     |-IntegerLiteral 0x557d797185d0 <col:19> 'int' 1
    |     `-IntegerLiteral 0x557d79717e18 <line:1:30> 'int' 2
    |-DeclStmt 0x557d797187d8 <line:4:3, col:12>
    | `-VarDecl 0x557d79718680 <col:3, col:11> col:8 b 'pair':'pair' listinit
    |   `-InitListExpr 0x557d79718750 <col:9, col:11> 'pair':'pair'
    |     |-IntegerLiteral 0x557d797186e8 <col:10> 'int' 1
    |     `-CXXDefaultInitExpr 0x557d797187a0 <col:11> 'int'
    `-CXXFunctionalCastExpr 0x557d797369a8 <col:14, col:20> 'pair':'pair' functional cast to pair <NoOp>
      `-InitListExpr 0x557d79718868 <col:18, col:20> 'pair':'pair'
        |-IntegerLiteral 0x557d79718800 <col:19> 'int' 1
        `-CXXDefaultInitExpr 0x557d797188b8 <col:20> 'int'

It feels like the ParentListExpr is replaced during semantic analysis and there is no way to get it back. I also tried running clang-query and trying to match parenListExpr() and go 0 results. Is it just missing in the AST dump and I run clang-query incorrectly or do we actually not have the syntactic form of this expression after all?

[ilya-biryukov]

clang/lib/CodeGen/CGExprAgg.cpp

577

Another important thing to address from the dump: notice how braced initialization creates CXXDefaultInitExpr and CXXParenListInitExpr copies the default argument expression directly. It's really important to use the former form, here's the example that currently breaks:

#include <iostream>

struct func_init { int some_int; const char* fn = __builtin_FUNCTION(); };

int main() {
  func_init a(10);
  std::cout << "From paren init:" << a.fn << std::endl;

  func_init b{10};
  std::cout << "From braced init: " << b.fn << std::endl;
}

The program above is expected to report main for both cases, but instead we get:

From paren init:
From braced init: main

[ayzhao]

implement CXXDefaultInitExpr and ImplicitValueInitExpr, array fillers, and semantic vs syntatic forms.

clang/lib/CodeGen/CGExprAgg.cpp

577

The following have now been implemented:

• CXXDefaultInitExpr and ImplicitValueInitExpr, which includes adding a test for __builtin_FUNCTION()
• Array fillers
• Semantic forms vs syntactic forms

[ilya-biryukov]

Thanks!

I have two major comments and also inline NITs. Not sure if we should block on those, just wanted to hear your opinions:

• InitListExpr and CXXParenInitListExpr have some code in common. Code duplication is substantial and I think sharing the common implementation is warranted. E.g. if some code would want to change something with ArrayFiller or make a use of it, the work will probably need to be duplicated. To reiterate what I mentioned earlier, I believe deriving CXXParenInitListExpr from InitListExpr is not a very good option, but we might explore other possibilities: a base class or factoring out common code in a separate struct. I believe this could be done with a follow-up change, though, as the amount of changes required does not seem too big, I would be happy with first landing this patch and then cleaning up with a follow-up change.
• Did we explore the possibility of modelling this differently and somehow avoiding making CXXParenInitListExpr an expression. This seems to borrow from InitListExpr, but maybe for the wrong reasons. Braced initializers can actually occur in expressions positions, e.g. int a = {123}. However, CXXParenInistListExpr cannot occur in expression positions outside initializations, e.g. having CXXFunctionalCastExpr for aggregate_struct(123) feels somewhat wrong to me and seems to lead to confusing error messages too. Maybe we should model it as a new expression that contains both the type and the argument list? I.e. more similar to CXXConstructExpr?

clang/lib/Sema/SemaInit.cpp

5446

NIT: s/expressionse/expressions

9709

NIT: add break

clang/lib/Sema/TreeTransform.h

13922

reinterpret_cast seems redundant here or am I missing something?

clang/lib/Serialization/ASTReaderStmt.cpp

2176

NIT: ExpectedNumExprs

2185

NIT: maybe add a comment that dependence does not depend on filler or syntactic form. This might be non-obvious for someone who did not look into the implementation.

Alternatively, you could run this at the end of this function, it should not be confusing to anyone that certain properties get computed *after* the expression was fully deserialized.

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

106

Do you have any idea why did this diagnostic change?

clang/test/CXX/drs/dr2xx.cpp

161

This might be related to other diagnostic change.
Why do we see the new behavior here? Do you think we should keep the old behavior maybe?
I feel that both errors are communicating the same thing and probably keeping the current state is acceptable, just want to better understand how we got there.

It definitely has something to do with the initialization code, but I struggle to understand what exactly changed

clang/test/CXX/temp/temp.decls/temp.variadic/p4.cpp

131

Given how pervasive this error is right now, I feel that we want to add a name of the struct to this message.
This case is also a good example of how this diagnostic can be really low quality with templates: it's unclear which exact base class causes a problem here from the compiler output,.

Maybe open a GH issue for that? It seems like an independent task that will also affect braced initializers and may need test file updates.

clang/test/PCH/cxx_paren_init.cpp

30 ↗

(On Diff #479758)

NIT: add a newline

clang/test/PCH/cxx_paren_init.h

6 ↗

(On Diff #479758)

NIT: add a newline

[ayzhao]

In D129531#3971392, @ilya-biryukov wrote:

Thanks!

I have two major comments and also inline NITs. Not sure if we should block on those, just wanted to hear your opinions:

• InitListExpr and CXXParenInitListExpr have some code in common. Code duplication is substantial and I think sharing the common implementation is warranted. E.g. if some code would want to change something with ArrayFiller or make a use of it, the work will probably need to be duplicated. To reiterate what I mentioned earlier, I believe deriving CXXParenInitListExpr from InitListExpr is not a very good option, but we might explore other possibilities: a base class or factoring out common code in a separate struct. I believe this could be done with a follow-up change, though, as the amount of changes required does not seem too big, I would be happy with first landing this patch and then cleaning up with a follow-up change.
• Did we explore the possibility of modelling this differently and somehow avoiding making CXXParenInitListExpr an expression. This seems to borrow from InitListExpr, but maybe for the wrong reasons. Braced initializers can actually occur in expressions positions, e.g. int a = {123}. However, CXXParenInistListExpr cannot occur in expression positions outside initializations, e.g. having CXXFunctionalCastExpr for aggregate_struct(123) feels somewhat wrong to me and seems to lead to confusing error messages too. Maybe we should model it as a new expression that contains both the type and the argument list? I.e. more similar to CXXConstructExpr?

As discussed offline, let's keep the current implementation as is for now.

[ayzhao]

use NumUserSpecifiedExprs instead of syntatic/semantic forms, also address some comments

[ayzhao]

clang/lib/CodeGen/CGExprAgg.cpp

577

Instead of implementing separate syntactic and semantic forms, I think it might be simpler and cleaner to store an unsigned NumUserSpecifiedExprs.

The reason for implementing it this way is that the purpose of having separate syntactic and semantic forms is to determine what the form in the code was originally as written and what the form is after semantic analysis. For InitListExpr, we need separate objects because there can be a significant difference in the two forms (e.g. designated initializers, etc.). However, CXXParenListInitExpr is much simpler - the first k expressions are user-specified, while the remaining are default/compiler-generated. Therefore, we can eliminate the complexity required for maintaining two forms (say, in TreeTransform) by just storing k.

N.B. this also resolves a build failure with an earlier diff where the libc++ bots were failing.

There is also precedence for this kind of structure - function calls with default arguments use similar logic instead of creating two Expr objects.

[ayzhao]

add missing EOF newline

[ayzhao]

restore original diagnostics

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

106

Fixed - I needed to add a line to SemaCast.cpp

clang/test/CXX/temp/temp.decls/temp.variadic/p4.cpp

131

Created https://github.com/llvm/llvm-project/issues/59367

[ayzhao]

clang/lib/Sema/SemaInit.cpp

5371

So the libc++ test compile failures are due to this line.

One example of a failing unit test is range.take.while/ctor.view.pass. Clang calls this function twice in TreeTransform.h - once with VerifyOnly set to true, once with it set to false.

For some reason, when this function tries to value-initialize the member MoveOnly mo in View, Seq.Failed() returns false after TryValueInitialization(...), but the resulting ExprResult is nullptr, causing the segfault we see when we push nullptr to InitExprs and pass InitExprs to the constructor of CXXParenListInitExpr. One way to be fix this is to move the line ExprResult ER = Seq.Perform(...) out of the if (!VerifyOnly) block and check for ER.isInvalid() instead of Seq.Failed(), but that results in test failures due to excess diagnostic messages in Seq.Perform(...)

I'm still looking into this, but if anyone has any ideas, they would be very welcome.

To repro the buildbot failures, just build clang with this patch, and then in a separate build directory, build the target check-cxx using the previously built clang.

[ayzhao]

rebase + (hopefully) fix libc++ c++2b test failures

clang/lib/Sema/SemaInit.cpp

5371

I was able to get the above workaround to pass the test by clearing the diagnostics after calling Seq.Perform(...).

IMO, this should be OK for now, but I'm open to better ideas if anyone has any.

[ayzhao]

clang/lib/AST/JSONNodeDumper.cpp

852

Yeah, I would definitely prefer to keep the current style. The problem though is that the buildbots run clang format and will fail if the patch isn't formatted correctly.

[ilya-biryukov]

clang/include/clang/AST/ExprCXX.h

4824

NIT: maybe just use return ArrayFiller? The code is much simpler and since functions are very close it's pretty much impossible that anyone would refactor one of those without looking at the other.

clang/lib/AST/ExprConstant.cpp

9979

NIT: !Args.empty() ? Args[0] : &VIE
Args.size() also works, but arguably captures the intent of the code a bit less clearly.

clang/lib/CodeGen/CGExprAgg.cpp

577

That looks fine indeed, I agree that CXXParenInitListExpr is simpler.

clang/lib/Sema/SemaInit.cpp

5272

NIT: reminder to remove this and other debug prints

5317

NIT: maybe rename to SubSeq or something similar?
Having both Seq and Sequence in scope with the same type is error-prone and hard to comprehend.

5371

Clearing all the diagnostics is a nuclear options and definitely seems off here. We should not call Perform() when VerifyOnly is true to avoid producing the diagnostics in the first place.

It's fine for the call with VerifyOnly = true to return no errors and later produce diagnostics with VerifyOnly = false, I believe this is what InitListChecker is already doing.
I have been playing around with the old version of the code, but couldn't fix it fully. I do have a small example that breaks, we should add it to the test and it should also be easier to understand what's going on:

struct MoveOnly
{
  MoveOnly(int data = 1);
  MoveOnly(const MoveOnly&) = delete;
  MoveOnly(MoveOnly&&) = default;
};

struct View {
  int a;
  MoveOnly mo;
};

void test() {
  View{0};
  View(0); // should work, but crashes and produces invalid diagnostics.
}

In general, my approach would be to try mimicing what InitListChecker is doing as much as possible, trimming all the unnecessary complexity that braced-init-lists entail.
Hope it's helpful.

[ayzhao]

address comments + rebase

[ayzhao]

clang/lib/Sema/SemaInit.cpp

5371

So it looks like all I had to do was remove the call to TryValueInitialization(...) and just check for Seq.Failed(). This is also what we do in InitListChecker.

The check-cxx target appears to work for me locally, so fingers crossed that the build passes.

I do have a small example that breaks, we should add it to the test and it should also be easier to understand what's going on:

Done.

[ilya-biryukov]

This LG, but not accepting as I believe libc++ is still broken if built with modules, right?
I have run check-cxx locally and it seems to work, but I suspect that's not using modules by default. I have clicked through the links in phrabricator and the errors seem to come from the latest uploaded diff.
Let me know if I'm missing something.

clang/lib/Sema/SemaInit.cpp

5371

Good catch! I have also noticed that TryValueInitialization is missing in InitListChecker, but somehow thought it's just doing the same thing without reusing the code.

[ilya-biryukov]

Since the errors only shows up in modular builds, I would look closely for bugs inside ASTReader/ASTWriter.
Also, it seems that ArrayFiller is not taken in to account in computeDependence and maybe it should be. I am not 100% sure, though: if ArrayFiller is only used for non-dependent code, it should not case this bug. It also does not explain the variation between modular and non-modular builds.

[ayzhao]

rebase + some compiler warning fixes

[ayzhao]

In D129531#3988996, @ilya-biryukov wrote:

Since the errors only shows up in modular builds, I would look closely for bugs inside ASTReader/ASTWriter.
Also, it seems that ArrayFiller is not taken in to account in computeDependence and maybe it should be. I am not 100% sure, though: if ArrayFiller is only used for non-dependent code, it should not case this bug. It also does not explain the variation between modular and non-modular builds.

These test failures are a little weird because they seem to alternate between being able to reliably reproduce vs not being able to reproduce at all.

One thing that I did notice is that the tests fail with RelWithDebInfo builds, but pass with all of the other builds (Debug, Release, and MinSizeRel). Right now though, I'm unable to reproduce the libc++ failure even with RelWithDebInfo.

Incidentally, I just rebased this patch, and it seems like the dr2xx.cpp test is also failing in a similar manner (fails on RelWithDebInfo but passes on other builds).

[ayzhao]

fix memory access issues identified by UBSan

[ayzhao]

In D129531#3990050, @ayzhao wrote:

In D129531#3988996, @ilya-biryukov wrote:

Since the errors only shows up in modular builds, I would look closely for bugs inside ASTReader/ASTWriter.

These test failures are a little weird because they seem to alternate between being able to reliably reproduce vs not being able to reproduce at all.

One thing that I did notice is that the tests fail with RelWithDebInfo builds, but pass with all of the other builds (Debug, Release, and MinSizeRel). Right now though, I'm unable to reproduce the libc++ failure even with RelWithDebInfo.

Incidentally, I just rebased this patch, and it seems like the dr2xx.cpp test is also failing in a similar manner (fails on RelWithDebInfo but passes on other builds).

All of the builds are green now - it turns out that I had to resolve 2 instances of UB in this patch.

Also, it seems that ArrayFiller is not taken in to account in computeDependence and maybe it should be. I am not 100% sure, though: if ArrayFiller is only used for non-dependent code, it should not case this bug. It also does not explain the variation between modular and non-modular builds

I don't think this should be an issue - InitListExpr doesn't take ArrayFiller into account in computeDependence(...) either: https://github.com/llvm/llvm-project/blob/c8647738cd654d9ecfdc047e480d05a997d3127b/clang/lib/AST/ComputeDependence.cpp#L636-L641

[ilya-biryukov]

LGTM! Thanks a lot for driving this to conclusion! Please note that there is one small NIT you may want to fix before landing this.
UB definitely explains why we saw the bugs. It's good that we caught it before this landed.

In D129531#3992998, @ayzhao wrote:

I don't think this should be an issue - InitListExpr doesn't take ArrayFiller into account in computeDependence(...) either: https://github.com/llvm/llvm-project/blob/c8647738cd654d9ecfdc047e480d05a997d3127b/clang/lib/AST/ComputeDependence.cpp#L636-L641

Yeah, makes sense, if InitListExpr does not take into account we are probably good here as well.
My intuition is that we can only figure out what to set in ArrayFiller when the expressions are non-dependent, therefore the filler itself should not add any extra "dependence" to the expression.
If that's the case, it would be nice to add an assertion. But that's unrelated to this change, we can do it some other day.

clang/lib/Sema/SemaInit.cpp

6111

NIT: use getFailureKind(), it asserts that Failed() == true and would have catched this particular UB.

[ayzhao]

use getFailureKind() + rebase

[shafik]

clang/include/clang/AST/ExprCXX.h

4761

It looks like we use this idiom in several places, it may be worth it to sink this as a member function of QualType

clang/lib/CodeGen/CGExprAgg.cpp

1601

This is second time I see you looking for the initialized field for a union while InitListExpr has getInitializedFieldInUnion(). Would it be too painful to also do that for CXXParenListInitExpr to avoid the code duplication?

clang/lib/Sema/SemaInit.cpp

5402

nit

[ayzhao]

clang/include/clang/AST/ExprCXX.h

4761

note: this patch was already merged, so I created a new patch addressing the revisions at D140159

It turns out there's a method getValueKindForType(...) that does the exact same thing, so I used that instead.

[hokein]

FYI, this patch triggers a crash in chromium, see https://github.com/llvm/llvm-project/issues/59675 for details.

[rsmith]

clang/lib/Sema/SemaInit.cpp

6110–6111

For when you look at re-landing this, we encountered a regression for this case:

struct A {};
struct B : A { Noncopyable nc; };

Here, given B b, a B(b) direct-initialization should be rejected because it selects a deleted copy constructor of B, but it looks like Clang instead performed aggregate initialization, as if by B{(const A&)b, {}}. This is pretty bad -- copies that should be disallowed end up working but not actually copying any members of the derived class!

The general problem is that Clang's overload resolution incorrectly handles deleted functions, treating them as an overload resolution failure rather than a success. In this particular case, what happens is constructor overload resolution produces OR_Deleted, which gets mapped into FK_ConstructorOverloadFailed despite the fact that overload resolution succeeded and picked a viable function.

I guess we can split FK_*OverloadFailed into separate "failed" and "succeeded but found a deleted function" cases?

[ayzhao]

clang/lib/Sema/SemaInit.cpp

6110–6111

For when you look at re-landing this, we encountered a regression for this case:

struct A {};
struct B : A { Noncopyable nc; };

Here, given B b, a B(b) direct-initialization should be rejected because it selects a deleted copy constructor of B, but it looks like Clang instead performed aggregate initialization, as if by B{(const A&)b, {}}. This is pretty bad -- copies that should be disallowed end up working but not actually copying any members of the derived class!

The general problem is that Clang's overload resolution incorrectly handles deleted functions, treating them as an overload resolution failure rather than a success. In this particular case, what happens is constructor overload resolution produces OR_Deleted, which gets mapped into FK_ConstructorOverloadFailed despite the fact that overload resolution succeeded and picked a viable function.

I guess we can split FK_*OverloadFailed into separate "failed" and "succeeded but found a deleted function" cases?

This was the cause of https://github.com/llvm/llvm-project/issues/59675 as well. The reland at D141546 should handle this case.

clang/include/clang-c/Index.h

enum CXCursorKind {
    */
   CXCursor_ConceptSpecializationExpr = 153,
 
   /**
    * Expression that references a C++20 concept.
    */
   CXCursor_RequiresExpr = 154,
 
-  CXCursor_LastExpr = CXCursor_RequiresExpr,
+  /**
+   * Expression that references a C++20 parenthesized list aggregate
+   * initializer.
+   *
+   */
+  CXCursor_CXXParenListInitExpr = 155,
+
+  CXCursor_LastExpr = CXCursor_CXXParenListInitExpr,
 
   /* Statements */
   CXCursor_FirstStmt = 200,
   /**
    * A statement whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed statements have the same operations as any other kind of

clang/include/clang/AST/Decl.h

public:
   enum InitializationStyle {
     /// C-style initialization with assignment
     CInit,
 
     /// Call-style initialization (C++98)
     CallInit,
 
     /// Direct list-initialization (C++11)
-    ListInit
+    ListInit,
+
+    /// Parenthesized list-initialization (C++20)
+    ParenListInit
   };
 
   /// Kinds of thread-local storage.
   enum TLSKind {
     /// Not a TLS variable.
     TLS_None,
 
     /// TLS with a known-constant initializer.

clang/include/clang/AST/ExprCXX.h

child_range children() {
     return child_range(SubExprs, SubExprs + SubExpr::Count);
   }
 
   const_child_range children() const {
     return const_child_range(SubExprs, SubExprs + SubExpr::Count);
   }
 };
 
+/// Represents a list-initialization with parenthesis.
+///
+/// As per P0960R3, this is a C++20 feature that allows aggregate to
+/// be initialized with a parenthesized list of values:
+/// ```
+/// struct A {
+///   int a;
+///   double b;
+/// };
+///
+/// void foo() {
+///   A a1(0);        // legal in C++20
+///   A a2(1.5, 1.0); // legal in C++20
+/// }
+/// ```
+/// It has some sort of similiarity to braced
+/// list-initialization, with some differences such as
+/// it allows narrowing conversion whilst braced
+/// list-initialization doesn't.
+/// ```
+/// struct A {
+///   char a;
+/// };
+/// void foo() {
+///   A a(1.5); // legal in C++20
+///   A b{1.5}; // illegal !
+/// }
+/// ```
+class CXXParenListInitExpr final
+    : public Expr,
+      private llvm::TrailingObjects<CXXParenListInitExpr, Expr *> {
+  friend class TrailingObjects;
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
+  unsigned NumExprs;
+  SourceLocation Loc;
+
+  CXXParenListInitExpr(ArrayRef<Expr *> Args, QualType T, SourceLocation Loc)
+      : Expr(CXXParenListInitExprClass, T,
+             T->isLValueReferenceType()   ? VK_LValue
+             : T->isRValueReferenceType() ? VK_XValue
+                                          : VK_PRValue,
+             OK_Ordinary),
+        NumExprs(Args.size()), Loc(Loc) {
+    std::copy(Args.begin(), Args.end(), getTrailingObjects<Expr *>());
+  }
+
+  size_t numTrailingObjects(OverloadToken<Expr *>) const { return NumExprs; }
+
+public:
+  static CXXParenListInitExpr *Create(ASTContext &C, ArrayRef<Expr *> Args,
+                                      QualType T, SourceLocation Loc);
+
+  explicit CXXParenListInitExpr(EmptyShell Empty)
+      : Expr(CXXParenListInitExprClass, Empty) {}
+
+  ArrayRef<Expr *> getInitExprs() {
+    return {getTrailingObjects<Expr *>(), NumExprs};
+  }
+
+  const ArrayRef<Expr *> getInitExprs() const {
+    return {getTrailingObjects<Expr *>(), NumExprs};
+  }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
+
+  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
+
+  SourceRange getSourceRange() const LLVM_READONLY {
+    return SourceRange(getBeginLoc(), getEndLoc());
+  }
+
+  child_range children() {
+    Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
+    return child_range(Begin, Begin + NumExprs);
+  }
+
+  const_child_range children() const {
+    Stmt *const *Begin =
+        reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
+    return const_child_range(Begin, Begin + NumExprs);
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == CXXParenListInitExprClass;
+  }
+};
+
 /// Represents an expression that might suspend coroutine execution;
 /// either a co_await or co_yield expression.
 ///
 /// Evaluation of this expression first evaluates its 'ready' expression. If
 /// that returns 'false':
 ///  -- execution of the coroutine is suspended
 ///  -- the 'suspend' expression is evaluated
 ///     -- if the 'suspend' expression returns 'false', the coroutine is
 ///        resumed
 ///     -- otherwise, control passes back to the resumer.
 /// If the coroutine is not suspended, or when it is resumed, the 'resume'
 /// expression is evaluated, and its result is the result of the overall
 /// expression.
 class CoroutineSuspendExpr : public Expr {
   friend class ASTStmtReader;
 
   SourceLocation KeywordLoc;
 
   enum SubExpr { Operand, Common, Ready, Suspend, Resume, Count };
 
   Stmt *SubExprs[SubExpr::Count];
   OpaqueValueExpr *OpaqueValue = nullptr;
 
 public:
   CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Operand,
                        Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume,
                        OpaqueValueExpr *OpaqueValue)

clang/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(CXXNoexceptExpr, {})
 DEF_TRAVERSE_STMT(PackExpansionExpr, {})
 DEF_TRAVERSE_STMT(SizeOfPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {})
 DEF_TRAVERSE_STMT(FunctionParmPackExpr, {})
 DEF_TRAVERSE_STMT(CXXFoldExpr, {})
 DEF_TRAVERSE_STMT(AtomicExpr, {})
+DEF_TRAVERSE_STMT(CXXParenListInitExpr, {})
 
 DEF_TRAVERSE_STMT(MaterializeTemporaryExpr, {
   if (S->getLifetimeExtendedTemporaryDecl()) {
     TRY_TO(TraverseLifetimeExtendedTemporaryDecl(
         S->getLifetimeExtendedTemporaryDecl()));
     ShouldVisitChildren = false;
   }
 })
 // For coroutines expressions, traverse either the operand

clang/include/clang/Basic/StmtNodes.td

 def PackExpansionExpr : StmtNode<Expr>;
 def SizeOfPackExpr : StmtNode<Expr>;
 def SubstNonTypeTemplateParmExpr : StmtNode<Expr>;
 def SubstNonTypeTemplateParmPackExpr : StmtNode<Expr>;
 def FunctionParmPackExpr : StmtNode<Expr>;
 def MaterializeTemporaryExpr : StmtNode<Expr>;
 def LambdaExpr : StmtNode<Expr>;
 def CXXFoldExpr : StmtNode<Expr>;
+def CXXParenListInitExpr: StmtNode<Expr>;
 
 // C++ Coroutines TS expressions
 def CoroutineSuspendExpr : StmtNode<Expr, 1>;
 def CoawaitExpr : StmtNode<CoroutineSuspendExpr>;
 def DependentCoawaitExpr : StmtNode<Expr>;
 def CoyieldExpr : StmtNode<CoroutineSuspendExpr>;
 
 // C++20 Concepts expressions

clang/include/clang/Sema/Initialization.h

enum StepKind {
     /// Perform initialization via a constructor taking a single
     /// std::initializer_list argument.
     SK_StdInitializerListConstructorCall,
 
     /// Initialize an OpenCL sampler from an integer.
     SK_OCLSamplerInit,
 
     /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero
-    SK_OCLZeroOpaqueType
+    SK_OCLZeroOpaqueType,
+
+    /// Initialize an aggreagate with parenthesized list of values.
+    /// This is a C++20 feature.
+    SK_ParenthesizedListInit
   };
 
   /// A single step in the initialization sequence.
   class Step {
   public:
     /// The kind of conversion or initialization step we are taking.
     StepKind Kind;
 
enum FailureKind {
     FK_PlaceholderType,
 
     /// Trying to take the address of a function that doesn't support
     /// having its address taken.
     FK_AddressOfUnaddressableFunction,
 
     /// List-copy-initialization chose an explicit constructor.
     FK_ExplicitConstructor,
+
+    /// Parenthesized list initialization failed at some point.
+    /// This is a C++20 feature.
+    FK_ParenthesizedListInitFailed,
   };
 
 private:
   /// The reason why initialization failed.
   FailureKind Failure;
 
   /// The failed result of overload resolution.
   OverloadingResult FailedOverloadResult;
public:
   /// Add a step to initialize an OpenCL sampler from an integer
   /// constant.
   void AddOCLSamplerInitStep(QualType T);
 
   /// Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.)
   /// from a zero constant.
   void AddOCLZeroOpaqueTypeStep(QualType T);
 
+  void AddParenthesizedListInitStep(QualType T);
+
   /// Add steps to unwrap a initializer list for a reference around a
   /// single element and rewrap it at the end.
   void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
 
   /// Note that this initialization sequence failed.
   void SetFailed(FailureKind Failure) {
     SequenceKind = FailedSequence;
     this->Failure = Failure;

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
   EXPR_USER_DEFINED_LITERAL,
 
   /// A CXXStdInitializerListExpr record.
   EXPR_CXX_STD_INITIALIZER_LIST,
 
   /// A CXXBoolLiteralExpr record.
   EXPR_CXX_BOOL_LITERAL,
 
+  /// A CXXParenListInitExpr record.
+  EXPR_CXX_PAREN_LIST_INIT,
+
   EXPR_CXX_NULL_PTR_LITERAL, // CXXNullPtrLiteralExpr
   EXPR_CXX_TYPEID_EXPR,      // CXXTypeidExpr (of expr).
   EXPR_CXX_TYPEID_TYPE,      // CXXTypeidExpr (of type).
   EXPR_CXX_THIS,             // CXXThisExpr
   EXPR_CXX_THROW,            // CXXThrowExpr
   EXPR_CXX_DEFAULT_ARG,      // CXXDefaultArgExpr
   EXPR_CXX_DEFAULT_INIT,     // CXXDefaultInitExpr
   EXPR_CXX_BIND_TEMPORARY,   // CXXBindTemporaryExpr

clang/lib/AST/Expr.cpp

bool Expr::HasSideEffects(const ASTContext &Ctx,
   case CXXPseudoDestructorExprClass:
   case CXXRewrittenBinaryOperatorClass:
   case CXXStdInitializerListExprClass:
   case SubstNonTypeTemplateParmExprClass:
   case MaterializeTemporaryExprClass:
   case ShuffleVectorExprClass:
   case ConvertVectorExprClass:
   case AsTypeExprClass:
+  case CXXParenListInitExprClass:
     // These have a side-effect if any subexpression does.
     break;
 
   case UnaryOperatorClass:
     if (cast<UnaryOperator>(this)->isIncrementDecrementOp())
       return true;
     break;
 
bool Expr::HasSideEffects(const ASTContext &Ctx,
   case ObjCPropertyRefExprClass:
   // FIXME: Classify these cases better.
     if (IncludePossibleEffects)
       return true;
     break;
   }
 
   // Recurse to children.
   for (const Stmt *SubStmt : children())
     if (SubStmt &&
         cast<Expr>(SubStmt)->HasSideEffects(Ctx, IncludePossibleEffects))
       return true;
 
   return false;
 }
 
 FPOptions Expr::getFPFeaturesInEffect(const LangOptions &LO) const {

clang/lib/AST/ExprCXX.cpp

CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
                                                     EmptyShell Empty) {
   // Allocate storage for the trailing objects of CallExpr.
   unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
       /*NumPreArgs=*/END_PREARG, NumArgs, HasFPFeatures);
   void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects,
                            alignof(CUDAKernelCallExpr));
   return new (Mem) CUDAKernelCallExpr(NumArgs, HasFPFeatures, Empty);
 }
+
+CXXParenListInitExpr *CXXParenListInitExpr::Create(ASTContext &C,
+                                                   ArrayRef<Expr *> Args,
+                                                   QualType T,
+                                                   SourceLocation Loc) {
+  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
+  return new (Mem) CXXParenListInitExpr(Args, T, Loc);
+}

clang/lib/AST/ExprClassification.cpp

case Expr::InitListExprClass:
     return ClassifyInternal(Ctx, cast<InitListExpr>(E)->getInit(0));
 
   case Expr::CoawaitExprClass:
   case Expr::CoyieldExprClass:
     return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
   case Expr::SYCLUniqueStableNameExprClass:
     return Cl::CL_PRValue;
     break;
+
+  case Expr::CXXParenListInitExprClass:
+    if (isa<ArrayType>(E->getType()))
+      return Cl::CL_ArrayTemporary;
+    return Cl::CL_ClassTemporary;
   }
 
   llvm_unreachable("unhandled expression kind in classification");
 }
 
 /// ClassifyDecl - Return the classification of an expression referencing the
 /// given declaration.
 static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D) {

clang/lib/AST/ExprConstant.cpp

public:
     bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
       return VisitCXXConstructExpr(E, E->getType());
     }
     bool VisitLambdaExpr(const LambdaExpr *E);
     bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
     bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
     bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
     bool VisitBinCmp(const BinaryOperator *E);
+    bool VisitCXXParenListInitExpr(const CXXParenListInitExpr *E);
+    bool VisitCXXParenListOrInitListExpr(const Expr *E,
+                                         ArrayRef<Expr *> InitExprs);
   };
 }
 
 /// Perform zero-initialization on an object of non-union class type.
 /// C++11 [dcl.init]p5:
 ///  To zero-initialize an object or reference of type T means:
 ///    [...]
 ///    -- if T is a (possibly cv-qualified) non-union class type,
case CK_UncheckedDerivedToBase: {
     return true;
   }
   }
 }
 
 bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
   if (E->isTransparent())
     return Visit(E->getInit(0));
+  return VisitCXXParenListOrInitListExpr(E, E->inits());
+}
 
+bool RecordExprEvaluator::VisitCXXParenListOrInitListExpr(
+    const Expr *E, ArrayRef<Expr *> InitExprs) {
   const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
   if (RD->isInvalidDecl()) return false;
   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
   auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
 
   EvalInfo::EvaluatingConstructorRAII EvalObj(
       Info,
       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
       CXXRD && CXXRD->getNumBases());
 
   if (RD->isUnion()) {
-    const FieldDecl *Field = E->getInitializedFieldInUnion();
+    const FieldDecl *Field;
+    if (isa<InitListExpr>(E)) {
+      Field = cast<InitListExpr>(E)->getInitializedFieldInUnion();
+    } else if (isa<CXXParenListInitExpr>(E)) {
+      assert(InitExprs.size() == 1 &&
+             "Number of expressions in C++ paren list is not 1");
+
+      for (const FieldDecl *FD : RD->fields()) {
+        if (!FD->isUnnamedBitfield()) {
+          Field = FD;
+          break;
+        }
+      }
+    } else {
+      llvm_unreachable(
+          "Expression is neither an init list nor a C++ paren list");
+    }
+
     Result = APValue(Field);
     if (!Field)
       return true;
 
     // If the initializer list for a union does not contain any elements, the
     // first element of the union is value-initialized.
     // FIXME: The element should be initialized from an initializer list.
     //        Is this difference ever observable for initializer lists which
     //        we don't build?
     ImplicitValueInitExpr VIE(Field->getType());
-    const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
+    const Expr *InitExpr = InitExprs.size() ? InitExprs[0] : &VIE;
 
     LValue Subobject = This;
     if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
       return false;
 
     // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
                                   isa<CXXDefaultInitExpr>(InitExpr));
if (!Result.hasValue())
     Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
                      std::distance(RD->field_begin(), RD->field_end()));
   unsigned ElementNo = 0;
   bool Success = true;
 
   // Initialize base classes.
   if (CXXRD && CXXRD->getNumBases()) {
     for (const auto &Base : CXXRD->bases()) {
-      assert(ElementNo < E->getNumInits() && "missing init for base class");
-      const Expr *Init = E->getInit(ElementNo);
+      assert(ElementNo < InitExprs.size() && "missing init for base class");
+      const Expr *Init = InitExprs[ElementNo];
 
       LValue Subobject = This;
       if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
         return false;
 
       APValue &FieldVal = Result.getStructBase(ElementNo);
       if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
         if (!Info.noteFailure())
bool RecordExprEvaluator::VisitCXXParenListOrInitListExpr(
   for (const auto *Field : RD->fields()) {
     // Anonymous bit-fields are not considered members of the class for
     // purposes of aggregate initialization.
     if (Field->isUnnamedBitfield())
       continue;
 
     LValue Subobject = This;
 
-    bool HaveInit = ElementNo < E->getNumInits();
+    bool HaveInit = ElementNo < InitExprs.size();
 
     // FIXME: Diagnostics here should point to the end of the initializer
     // list, not the start.
-    if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
+    if (!HandleLValueMember(Info, HaveInit ? InitExprs[ElementNo] : E,
                             Subobject, Field, &Layout))
       return false;
 
     // Perform an implicit value-initialization for members beyond the end of
     // the initializer list.
     ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
-    const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
+    const Expr *Init = HaveInit ? InitExprs[ElementNo++] : &VIE;
 
     if (Field->getType()->isIncompleteArrayType()) {
       if (auto *CAT = Info.Ctx.getAsConstantArrayType(Init->getType())) {
         if (!CAT->getSize().isZero()) {
           // Bail out for now. This might sort of "work", but the rest of the
           // code isn't really prepared to handle it.
           Info.FFDiag(Init, diag::note_constexpr_unsupported_flexible_array);
           return false;
public:
     bool VisitCXXConstructExpr(const CXXConstructExpr *E,
                                const LValue &Subobject,
                                APValue *Value, QualType Type);
     bool VisitStringLiteral(const StringLiteral *E,
                             QualType AllocType = QualType()) {
       expandStringLiteral(Info, E, Result, AllocType);
       return true;
     }
+    bool VisitCXXParenListInitExpr(const CXXParenListInitExpr *E);
   };
 } // end anonymous namespace
 
 static bool EvaluateArray(const Expr *E, const LValue &This,
                           APValue &Result, EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isArrayType() &&
          "not an array prvalue");
bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
 
   if (!Type->isRecordType())
     return Error(E);
 
   return RecordExprEvaluator(Info, Subobject, *Value)
              .VisitCXXConstructExpr(E, Type);
 }
 
+bool ArrayExprEvaluator::VisitCXXParenListInitExpr(
+    const CXXParenListInitExpr *E) {
+  const auto *CAT = dyn_cast<ConstantArrayType>(E->getType());
+  assert(CAT && "Expression result is not a constant array type");
+
+  const ArrayRef<Expr *> InitExprs = E->getInitExprs();
+  unsigned NumElts = InitExprs.size();
+  Result = APValue(APValue::UninitArray(), NumElts, NumElts);
+
+  LValue Subobject = This;
+  Subobject.addArray(Info, E, CAT);
+
+  for (unsigned Index = 0; Index < NumElts; Index++)
+    if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), Info, Subobject,
+                         InitExprs[Index]))
+      return false;
+
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // Integer Evaluation
 //
 // As a GNU extension, we support casting pointers to sufficiently-wide integer
 // types and back in constant folding. Integer values are thus represented
 // either as an integer-valued APValue, or as an lvalue-valued APValue.
 //===----------------------------------------------------------------------===//
 
auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
     return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
                                    ConstantExprKind::Normal);
   };
   return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
     return ExprEvaluatorBaseTy::VisitBinCmp(E);
   });
 }
 
+bool RecordExprEvaluator::VisitCXXParenListInitExpr(
+    const CXXParenListInitExpr *E) {
+  return VisitCXXParenListOrInitListExpr(E, E->getInitExprs());
+}
+
 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
   // We don't support assignment in C. C++ assignments don't get here because
   // assignment is an lvalue in C++.
   if (E->isAssignmentOp()) {
     Error(E);
     if (!Info.noteFailure())
       return false;
   }
#include "clang/AST/StmtNodes.inc"
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::LambdaExprClass:
   case Expr::CXXFoldExprClass:
   case Expr::CoawaitExprClass:
   case Expr::DependentCoawaitExprClass:
   case Expr::CoyieldExprClass:
   case Expr::SYCLUniqueStableNameExprClass:
+  case Expr::CXXParenListInitExprClass:
     return ICEDiag(IK_NotICE, E->getBeginLoc());
 
   case Expr::InitListExprClass: {
     // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the
     // form "T x = { a };" is equivalent to "T x = a;".
     // Unless we're initializing a reference, T is a scalar as it is known to be
     // of integral or enumeration type.
     if (E->isPRValue())
#include "clang/AST/StmtNodes.inc"
   }
   case Expr::BuiltinBitCastExprClass: {
     if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E)))
       return ICEDiag(IK_NotICE, E->getBeginLoc());
     return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx);
   }
   }
 
   llvm_unreachable("Invalid StmtClass!");
 }
 
 /// Evaluate an expression as a C++11 integral constant expression.
 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
                                                     const Expr *E,
                                                     llvm::APSInt *Value,
                                                     SourceLocation *Loc) {
   if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {

clang/lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
   case Expr::TypoExprClass: // This should no longer exist in the AST by now.
   case Expr::RecoveryExprClass:
   case Expr::OMPArraySectionExprClass:
   case Expr::OMPArrayShapingExprClass:
   case Expr::OMPIteratorExprClass:
   case Expr::CXXInheritedCtorInitExprClass:
+  case Expr::CXXParenListInitExprClass:
     llvm_unreachable("unexpected statement kind");
 
   case Expr::ConstantExprClass:
     E = cast<ConstantExpr>(E)->getSubExpr();
     goto recurse;
 
   // FIXME: invent manglings for all these.
   case Expr::BlockExprClass:

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitVarDecl(const VarDecl *VD) {
   attributeOnlyIfTrue("inline", VD->isInline());
   attributeOnlyIfTrue("constexpr", VD->isConstexpr());
   attributeOnlyIfTrue("modulePrivate", VD->isModulePrivate());
   if (VD->hasInit()) {
     switch (VD->getInitStyle()) {
     case VarDecl::CInit: JOS.attribute("init", "c");  break;
     case VarDecl::CallInit: JOS.attribute("init", "call"); break;
     case VarDecl::ListInit: JOS.attribute("init", "list"); break;
+    case VarDecl::ParenListInit:
+      JOS.attribute("init", "paren-list");
+      break;
     }
   }
   attributeOnlyIfTrue("isParameterPack", VD->isParameterPack());
 }
 
 void JSONNodeDumper::VisitFieldDecl(const FieldDecl *FD) {
   VisitNamedDecl(FD);
   JOS.attribute("type", createQualType(FD->getType()));

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {
   OS << "...";
   if (E->getRHS()) {
     OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
     PrintExpr(E->getRHS());
   }
   OS << ")";
 }
 
+void StmtPrinter::VisitCXXParenListInitExpr(CXXParenListInitExpr *Node) {
+  OS << "(";
+  unsigned i = 0;
+  for (Expr *E : Node->getInitExprs()) {
+    if (i)
+      OS << ", ";
+    PrintExpr(E);
+    i++;
+  }
+  OS << ")";
+}
+
 void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
   NestedNameSpecifierLoc NNS = E->getNestedNameSpecifierLoc();
   if (NNS)
     NNS.getNestedNameSpecifier()->print(OS, Policy);
   if (E->getTemplateKWLoc().isValid())
     OS << "template ";
   OS << E->getFoundDecl()->getName();
   printTemplateArgumentList(OS, E->getTemplateArgsAsWritten()->arguments(),

clang/lib/AST/StmtProfile.cpp

void StmtProfiler::VisitMaterializeTemporaryExpr(
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOperator());
 }
 
+void StmtProfiler::VisitCXXParenListInitExpr(const CXXParenListInitExpr *S) {
+  VisitExpr(S);
+}
+
 void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
   VisitStmt(S);
 }
 
 void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
   VisitStmt(S);
 }
 

clang/lib/AST/TextNodeDumper.cpp

case VarDecl::CInit:
       OS << " cinit";
       break;
     case VarDecl::CallInit:
       OS << " callinit";
       break;
     case VarDecl::ListInit:
       OS << " listinit";
       break;
+    case VarDecl::ParenListInit:
+      OS << " parenlistinit";
     }
   }
   if (D->needsDestruction(D->getASTContext()))
     OS << " destroyed";
   if (D->isParameterPack())
     OS << " pack";
 
   if (D->hasInit()) {

clang/lib/CodeGen/CGExprAgg.cpp

public:
   void EmitFinalDestCopy(QualType type, RValue src);
   void EmitCopy(QualType type, const AggValueSlot &dest,
                 const AggValueSlot &src);
 
   void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
 
   void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
                      QualType ArrayQTy, InitListExpr *E);
 
   AggValueSlot::NeedsGCBarriers_t needsGC(QualType T) {
     if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T))
       return AggValueSlot::NeedsGCBarriers;
     return AggValueSlot::DoesNotNeedGCBarriers;
   }
 
   bool TypeRequiresGCollection(QualType T);
 
if (E->isGLValue()) {
       LValue LV = CGF.EmitPseudoObjectLValue(E);
       return EmitFinalDestCopy(E->getType(), LV);
     }
 
     CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
   }
 
   void VisitVAArgExpr(VAArgExpr *E);
+  void VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
 
   void EmitInitializationToLValue(Expr *E, LValue Address);
   void EmitNullInitializationToLValue(LValue Address);
   //  case Expr::ChooseExprClass:
   void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
   void VisitAtomicExpr(AtomicExpr *E) {
     RValue Res = CGF.EmitAtomicExpr(E);
     EmitFinalDestCopy(E->getType(), Res);
static bool isTrivialFiller(Expr *E) {
 
   // FIXME: Are there other cases where we can avoid emitting an initializer?
   return false;
 }
 
 /// Emit initialization of an array from an initializer list.
 void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
                                    QualType ArrayQTy, InitListExpr *E) {
   uint64_t NumInitElements = E->getNumInits();
 
   uint64_t NumArrayElements = AType->getNumElements();
   assert(NumInitElements <= NumArrayElements);
 
   QualType elementType =
       CGF.getContext().getAsArrayType(ArrayQTy)->getElementType();
 
   // DestPtr is an array*.  Construct an elementType* by drilling
for (uint64_t i = 0; i != NumInitElements; ++i) {
 
     LValue elementLV = CGF.MakeAddrLValue(
         Address(element, llvmElementType, elementAlign), elementType);
     EmitInitializationToLValue(E->getInit(i), elementLV);
   }
 
   // Check whether there's a non-trivial array-fill expression.
   Expr *filler = E->getArrayFiller();
   bool hasTrivialFiller = isTrivialFiller(filler);
 
   // Any remaining elements need to be zero-initialized, possibly
   // using the filler expression.  We can skip this if the we're
   // emitting to zeroed memory.
   if (NumInitElements != NumArrayElements &&
       !(Dest.isZeroed() && hasTrivialFiller &&
         CGF.getTypes().isZeroInitializable(elementType))) {
 
void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
   } else {
     // There's a potential optimization opportunity in combining
     // memsets; that would be easy for arrays, but relatively
     // difficult for structures with the current code.
     CGF.EmitNullInitialization(lv.getAddress(CGF), lv.getType());
   }
 }
 
+void AggExprEmitter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
+  ArrayRef<Expr *> InitExprs = E->getInitExprs();
+  AggValueSlot Dest = EnsureSlot(E->getType());
+
+  if (const ArrayType *AT = dyn_cast<ArrayType>(E->getType())) {
+    for (auto Pair : llvm::enumerate(InitExprs)) {
+      // Initialization for every element of the array.
+      Address V = Builder.CreateConstArrayGEP(Dest.getAddress(), Pair.index());
+      LValue LV = CGF.MakeAddrLValue(V, AT->getElementType());
+      EmitInitializationToLValue(Pair.value(), LV);
+    }
+  } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(
+                 E->getType()->castAs<RecordType>()->getDecl())) {
+
+    unsigned Index = 0;
+    LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
+
+    // Initialize the base classes first.
+    for (auto &Base : RD->bases()) {
+      if (Index < InitExprs.size()) {
+        const CXXRecordDecl *BaseRD = Base.getType()->getAsCXXRecordDecl();
+        Address V = CGF.GetAddressOfDirectBaseInCompleteClass(
+            Dest.getAddress(), RD, BaseRD,
+            /*isBaseVirtual*/ false);
+        AggValueSlot AggSlot = AggValueSlot::forAddr(
+            V, Qualifiers(), AggValueSlot::IsDestructed,
+            AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased,
+            CGF.getOverlapForBaseInit(RD, BaseRD, Base.isVirtual()));
+        CGF.EmitAggExpr(InitExprs[Index++], AggSlot);
+      }
+    }
+
+    // Then initialize the fields.
+    for (const FieldDecl *F : RD->fields()) {
+      if (!F->isUnnamedBitfield() && Index < InitExprs.size()) {
+        LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, F);
+        EmitInitializationToLValue(InitExprs[Index++], LV);
+      }
+    }
+  }
+}
+
 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
 #if 0
   // FIXME: Assess perf here?  Figure out what cases are worth optimizing here
   // (Length of globals? Chunks of zeroed-out space?).
   //
   // If we can, prefer a copy from a global; this is a lot less code for long
   // globals, and it's easier for the current optimizers to analyze.
   if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {

clang/lib/Sema/SemaDecl.cpp

if (Result.isInvalid()) {
       VDecl->setInvalidDecl();
       return;
     }
     Init = Result.get();
   }
 
   // Perform the initialization.
   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
+  bool IsParenListInit = false;
   if (!VDecl->isInvalidDecl()) {
     InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
     InitializationKind Kind = InitializationKind::CreateForInit(
         VDecl->getLocation(), DirectInit, Init);
 
     MultiExprArg Args = Init;
     if (CXXDirectInit)
       Args = MultiExprArg(CXXDirectInit->getExprs(),
if (Result.isInvalid()) {
       auto RecoveryExpr =
           CreateRecoveryExpr(Init->getBeginLoc(), Init->getEndLoc(), Args);
       if (RecoveryExpr.get())
         VDecl->setInit(RecoveryExpr.get());
       return;
     }
 
     Init = Result.getAs<Expr>();
+    IsParenListInit = InitSeq.step_begin()->Kind ==
+                      InitializationSequence::SK_ParenthesizedListInit;
   }
 
   // Check for self-references within variable initializers.
   // Variables declared within a function/method body (except for references)
   // are handled by a dataflow analysis.
   // This is undefined behavior in C++, but valid in C.
   if (getLangOpts().CPlusPlus)
     if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
   // special case code.
 
   // C++ 8.5p11:
   // The form of initialization (using parentheses or '=') is generally
   // insignificant, but does matter when the entity being initialized has a
   // class type.
   if (CXXDirectInit) {
     assert(DirectInit && "Call-style initializer must be direct init.");
-    VDecl->setInitStyle(VarDecl::CallInit);
+    VDecl->setInitStyle(IsParenListInit ? VarDecl::ParenListInit
+                                        : VarDecl::CallInit);
   } else if (DirectInit) {
     // This must be list-initialization. No other way is direct-initialization.
     VDecl->setInitStyle(VarDecl::ListInit);
   }
 
   if (LangOpts.OpenMP &&
       (LangOpts.OpenMPIsDevice || !LangOpts.OMPTargetTriples.empty()) &&
       VDecl->isFileVarDecl())

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::ObjCIsaExprClass:
   case Expr::ObjCIvarRefExprClass:
   case Expr::ParenExprClass:
   case Expr::ParenListExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::VAArgExprClass:
+  case Expr::CXXParenListInitExprClass:
     return canSubStmtsThrow(*this, S);
 
   case Expr::CompoundLiteralExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::CXXAddrspaceCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
   case Expr::BuiltinBitCastExprClass:
       // FIXME: Properly determine whether a variably-modified type can throw.

clang/lib/Sema/SemaInit.cpp

void InitializationSequence::Step::Destroy() {
   case SK_ParenthesizedArrayInit:
   case SK_PassByIndirectCopyRestore:
   case SK_PassByIndirectRestore:
   case SK_ProduceObjCObject:
   case SK_StdInitializerList:
   case SK_StdInitializerListConstructorCall:
   case SK_OCLSamplerInit:
   case SK_OCLZeroOpaqueType:
+  case SK_ParenthesizedListInit:
     break;
 
   case SK_ConversionSequence:
   case SK_ConversionSequenceNoNarrowing:
     delete ICS;
+    break;
   }
 }
 
 bool InitializationSequence::isDirectReferenceBinding() const {
   // There can be some lvalue adjustments after the SK_BindReference step.
   for (const Step &S : llvm::reverse(Steps)) {
     if (S.Kind == SK_BindReference)
       return true;
bool InitializationSequence::isAmbiguous() const {
   case FK_Incomplete:
   case FK_ArrayTypeMismatch:
   case FK_NonConstantArrayInit:
   case FK_ListInitializationFailed:
   case FK_VariableLengthArrayHasInitializer:
   case FK_PlaceholderType:
   case FK_ExplicitConstructor:
   case FK_AddressOfUnaddressableFunction:
+  case FK_ParenthesizedListInitFailed:
     return false;
 
   case FK_ReferenceInitOverloadFailed:
   case FK_UserConversionOverloadFailed:
   case FK_ConstructorOverloadFailed:
   case FK_ListConstructorOverloadFailed:
     return FailedOverloadResult == OR_Ambiguous;
   }

 
 void InitializationSequence::AddOCLZeroOpaqueTypeStep(QualType T) {
   Step S;
   S.Kind = SK_OCLZeroOpaqueType;
   S.Type = T;
   Steps.push_back(S);
 }
 
+void InitializationSequence::AddParenthesizedListInitStep(QualType T) {
+  Step S;
+  S.Kind = SK_ParenthesizedListInit;
+  S.Type = T;
+  Steps.push_back(S);
+}
+
 void InitializationSequence::RewrapReferenceInitList(QualType T,
                                                      InitListExpr *Syntactic) {
   assert(Syntactic->getNumInits() == 1 &&
          "Can only rewrap trivial init lists.");
   Step S;
   S.Kind = SK_UnwrapInitList;
   S.Type = Syntactic->getInit(0)->getType();
   Steps.insert(Steps.begin(), S);
static void TryConstructorInitialization(Sema &S,
   //     through overload resolution.
   DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
 
   OverloadingResult Result = OR_No_Viable_Function;
   OverloadCandidateSet::iterator Best;
   bool AsInitializerList = false;
 
   // C++11 [over.match.list]p1, per DR1467:
   //   When objects of non-aggregate type T are list-initialized, such that
   //   8.5.4 [dcl.init.list] specifies that overload resolution is performed
   //   according to the rules in this section, overload resolution selects
   //   the constructor in two phases:
   //
   //   - Initially, the candidate functions are the initializer-list
   //     constructors of the class T and the argument list consists of the
   //     initializer list as a single argument.
   if (IsListInit) {
     AsInitializerList = true;
 
static void TryConstructorInitialization(Sema &S,
   if (Result == OR_No_Viable_Function) {
     AsInitializerList = false;
     Result = ResolveConstructorOverload(S, Kind.getLocation(), UnwrappedArgs,
                                         CandidateSet, DestType, Ctors, Best,
                                         CopyInitialization, AllowExplicit,
                                         /*OnlyListConstructors=*/false,
                                         IsListInit);
   }
   if (Result) {
     Sequence.SetOverloadFailure(
         IsListInit ? InitializationSequence::FK_ListConstructorOverloadFailed
                    : InitializationSequence::FK_ConstructorOverloadFailed,
         Result);
 
     if (Result != OR_Deleted)
       return;
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   // In C++17, ResolveConstructorOverload can select a conversion function
   // instead of a constructor.
   if (auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
     // Add the user-defined conversion step that calls the conversion function.
     QualType ConvType = CD->getConversionType();
     assert(S.Context.hasSameUnqualifiedType(ConvType, DestType) &&
            "should not have selected this conversion function");
     Sequence.AddUserConversionStep(CD, Best->FoundDecl, ConvType,
                                    HadMultipleCandidates);
     if (!S.Context.hasSameType(ConvType, DestType))
       Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
     if (IsListInit)
       Sequence.RewrapReferenceInitList(Entity.getType(), ILE);
     return;
   }
 
   CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
   if (Result != OR_Deleted) {
     // C++11 [dcl.init]p6:
     //   If a program calls for the default initialization of an object
     //   of a const-qualified type T, T shall be a class type with a
     //   user-provided default constructor.
     // C++ core issue 253 proposal:
static void TryDefaultInitialization(Sema &S,
 
   // If the destination type has a lifetime property, zero-initialize it.
   if (DestType.getQualifiers().hasObjCLifetime()) {
     Sequence.AddZeroInitializationStep(Entity.getType());
     return;
   }
 }
 
+static void TryOrBuildParenListInitialization(
+    Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
+    ArrayRef<Expr *> Args, InitializationSequence &Sequence, bool VerifyOnly,
+    ExprResult *Result = nullptr) {
+  unsigned Index = 0;
+  SmallVector<Expr *, 4> InitExprs;
+  QualType ResultType;
+
+  auto InitHelper = [&](auto Range) -> bool {
+    for (InitializedEntity SubEntity : Range) {
+      if (Index == 1 && Entity.getType()->isUnionType())
+        // Unions should only have one initializer expression.
+        return true;
+
+      if (SubEntity.getKind() == InitializedEntity::EK_Member &&
+          cast<FieldDecl>(SubEntity.getDecl())->isUnnamedBitfield())
+        continue;
+
+      if (Index == Args.size()) {
+        if (SubEntity.getKind() == InitializedEntity::EK_Member) {
+          // C++ [dcl.init]p17.6.2.2
+          //   The remaining elements are initialized with their default member
+          //   initializers, if any, and otherwise are value-initialized.
+          const auto *FD = cast<FieldDecl>(SubEntity.getDecl());
+          if (Expr *ICE = FD->getInClassInitializer()) {
+            InitExprs.push_back(ICE);
+            continue;
+          };
+        }
+        InitializationKind SubKind = InitializationKind::CreateValue(
+            Kind.getLocation(), Kind.getLocation(), Kind.getLocation());
+        InitializationSequence Seq(S, SubEntity, SubKind, None);
+        TryValueInitialization(S, SubEntity, SubKind, Seq);
+        if (Seq.Failed()) {
+          if (!VerifyOnly)
+            Seq.Diagnose(S, SubEntity, SubKind, None);
+          return false;
+        }
+        if (!VerifyOnly) {
+          ExprResult ER = Seq.Perform(S, SubEntity, SubKind, None);
+          InitExprs.push_back(ER.get());
+        }
+        continue;
+      }
+
+      Expr *E = Args[Index++];
+      InitializationKind SubKind = InitializationKind::CreateForInit(
+          E->getExprLoc(), /*isDirectInit*/ false, E);
+      InitializationSequence Seq(S, SubEntity, SubKind, E);
+
+      if (Seq.Failed()) {
+        if (!VerifyOnly)
+          Seq.Diagnose(S, SubEntity, SubKind, E);
+        else
+          Sequence.SetFailed(
+              InitializationSequence::FK_ParenthesizedListInitFailed);
+
+        return false;
+      }
+      if (!VerifyOnly) {
+        ExprResult ER = Seq.Perform(S, SubEntity, SubKind, E);
+        InitExprs.push_back(ER.get());
+      }
+    }
+    return true;
+  };
+
+  if (const ArrayType *AT =
+          S.getASTContext().getAsArrayType(Entity.getType())) {
+
+    SmallVector<InitializedEntity, 4> ElementEntities;
+    uint64_t ArrayLength;
+    if (const ConstantArrayType *CAT =
+            S.getASTContext().getAsConstantArrayType(Entity.getType()))
+      ArrayLength = CAT->getSize().getZExtValue();
+    else
+      ArrayLength = Args.size();
+
+    if (ArrayLength >= Args.size()) {
+      for (uint64_t I = 0; I < ArrayLength; ++I)
+        ElementEntities.push_back(
+            InitializedEntity::InitializeElement(S.getASTContext(), I, Entity));
+
+      if (!InitHelper(ElementEntities))
+        return;
+
+      ResultType = S.Context.getConstantArrayType(
+          AT->getElementType(), llvm::APInt(32, ArrayLength), nullptr,
+          ArrayType::Normal, 0);
+    }
+  } else if (auto *RT = Entity.getType()->getAs<RecordType>()) {
+    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
+
+    auto BaseRange = map_range(RD->bases(), [&S](auto &base) {
+      return InitializedEntity::InitializeBase(S.getASTContext(), &base, false);
+    });
+    auto FieldRange = map_range(RD->fields(), [](auto *field) {
+      return InitializedEntity::InitializeMember(field);
+    });
+
+    if (!InitHelper(BaseRange))
+      return;
+
+    if (!InitHelper(FieldRange))
+      return;
+
+    ResultType = Entity.getType();
+  }
+
+  if (Index != Args.size()) {
+    if (!VerifyOnly) {
+      QualType T = Entity.getType();
+      int InitKind = T->isArrayType() ? 0 : T->isUnionType() ? 3 : 4;
+      S.Diag(Kind.getLocation(), diag::err_excess_initializers)
+          << InitKind << Args[Index]->getSourceRange();
+    } else {
+      Sequence.SetFailed(
+          InitializationSequence::FK_ParenthesizedListInitFailed);
+    }
+    return;
+  }
+
+  if (VerifyOnly) {
+    Sequence.setSequenceKind(InitializationSequence::NormalSequence);
+    Sequence.AddParenthesizedListInitStep(Entity.getType());
+  } else if (Result) {
+    *Result = CXXParenListInitExpr::Create(S.getASTContext(), InitExprs,
+                                           ResultType, Kind.getLocation());
+  }
+
+  return;
+}
+
 /// Attempt a user-defined conversion between two types (C++ [dcl.init]),
 /// which enumerates all conversion functions and performs overload resolution
 /// to select the best.
 static void TryUserDefinedConversion(Sema &S,
                                      QualType DestType,
                                      const InitializationKind &Kind,
                                      Expr *Initializer,
                                      InitializationSequence &Sequence,
                                      bool TopLevelOfInitList) {
   assert(!DestType->isReferenceType() && "References are handled elsewhere");
   QualType SourceType = Initializer->getType();
   assert((DestType->isRecordType() || SourceType->isRecordType()) &&
          "Must have a class type to perform a user-defined conversion");
 
   // Build the candidate set directly in the initialization sequence
if (S.isCompleteType(Kind.getLocation(), DestType)) {
                 /*ExplicitArgs*/ nullptr, Initializer, CandidateSet,
                 /*SuppressUserConversions=*/true,
                 /*PartialOverloading*/ false, AllowExplicit);
           else
             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
                                    Initializer, CandidateSet,
                                    /*SuppressUserConversions=*/true,
                                    /*PartialOverloading*/ false, AllowExplicit);
         }
       }
     }
   }
 
   SourceLocation DeclLoc = Initializer->getBeginLoc();
 
   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
     // The type we're converting from is a class type, enumerate its conversion
if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
     // Note: as a GNU C++ extension, we allow list-initialization of a
     // class member of array type from a parenthesized initializer list.
     else if (S.getLangOpts().CPlusPlus &&
              Entity.getKind() == InitializedEntity::EK_Member &&
              Initializer && isa<InitListExpr>(Initializer)) {
       TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
                             *this, TreatUnavailableAsInvalid);
       AddParenthesizedArrayInitStep(DestType);
-    } else if (DestAT->getElementType()->isCharType())
+    } else if (S.getLangOpts().CPlusPlus20 && !TopLevelOfInitList)
+      TryOrBuildParenListInitialization(S, Entity, Kind, Args, *this,
+                                        /*VerifyOnly=*/true);
+    else if (DestAT->getElementType()->isCharType())
       SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
     else if (IsWideCharCompatible(DestAT->getElementType(), Context))
       SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
     else
       SetFailed(FK_ArrayNeedsInitList);
 
     return;
   }
void InitializationSequence::InitializeFrom(Sema &S,
   if (DestType->isRecordType()) {
     //     - If the initialization is direct-initialization, or if it is
     //       copy-initialization where the cv-unqualified version of the
     //       source type is the same class as, or a derived class of, the
     //       class of the destination, constructors are considered. [...]
     if (Kind.getKind() == InitializationKind::IK_Direct ||
         (Kind.getKind() == InitializationKind::IK_Copy &&
          (Context.hasSameUnqualifiedType(SourceType, DestType) ||
-          S.IsDerivedFrom(Initializer->getBeginLoc(), SourceType, DestType))))
-      TryConstructorInitialization(S, Entity, Kind, Args,
-                                   DestType, DestType, *this);
+          S.IsDerivedFrom(Initializer->getBeginLoc(), SourceType, DestType)))) {
+      TryConstructorInitialization(S, Entity, Kind, Args, DestType, DestType,
+                                   *this);
+
+      // We fall back to the "no matching constructor "path iff the
+      // failed candidate set has function other than the three default
+      // constructors. For example, conversion function.
+      if (const CXXRecordDecl *RD =
+              dyn_cast<CXXRecordDecl>(DestType->getAs<RecordType>()->getDecl());
+          S.getLangOpts().CPlusPlus20 && RD && RD->isAggregate() &&
+          Failure == FK_ConstructorOverloadFailed &&
+          getFailedCandidateSet().size() == 3) {
+        // const ValueDecl *VD = Entity.getDecl();
+        // if (const VarDecl *VarD = dyn_cast_or_null<VarDecl>(VD);
+        //     VarD && VarD->hasInit() && !VarD->getInit()->containsErrors())
+        // C++20 [dcl.init] 17.6.2.2:
+        //   - Otherwise, if no constructor is viable, the destination type is
+        //   an
+        //      aggregate class, and the initializer is a parenthesized
+        //      expression-list, the object is initialized as follows. Let e1,
+        //      ..., en be the elements of the aggregate . Let x1, ..., xk be
+        //      the elements of the expression-list. If k is greater than n,
+        //      the program is ill-formed. The element ei is copy-initialized
+        //      with xi for 1 <= i <= k. The remaining elements are
+        //      initialized with their default member initializers, if any,
+        //      and otherwise are value-initialized. For each 1 <= i < j <= n,
+        //      every value computation and side effect associated with the
+        //      initialization of ei is sequenced before those associated with
+        //      the initialization of ej. Note: By contrast with
+        //      direct-list-initialization, narrowing conversions (9.4.4) are
+        //      permitted, designators are not permitted, a temporary object
+        //      bound to a reference does not have its lifetime extended
+        //      (6.7.7), and there is no brace elision.
+        TryOrBuildParenListInitialization(S, Entity, Kind, Args, *this,
+                                          /*VerifyOnly=*/true);
+      }
+    } else {
       //     - Otherwise (i.e., for the remaining copy-initialization cases),
-    //       user-defined conversion sequences that can convert from the source
-    //       type to the destination type or (when a conversion function is
-    //       used) to a derived class thereof are enumerated as described in
-    //       13.3.1.4, and the best one is chosen through overload resolution
-    //       (13.3).
-    else
+      //       user-defined conversion sequences that can convert from the
+      //       source type to the destination type or (when a conversion
+      //       function is used) to a derived class thereof are enumerated as
+      //       described in 13.3.1.4, and the best one is chosen through
+      //       overload resolution (13.3).
       TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
                                TopLevelOfInitList);
+    }
     return;
   }
 
   assert(Args.size() >= 1 && "Zero-argument case handled above");
 
   // For HLSL ext vector types we allow list initialization behavior for C++
   // constructor syntax. This is accomplished by converting initialization
   // arguments an InitListExpr late.
case SK_OCLZeroOpaqueType: {
     if (!CurInit.get()) return ExprError();
     break;
   }
 
   case SK_ConstructorInitialization:
   case SK_ConstructorInitializationFromList:
   case SK_StdInitializerListConstructorCall:
   case SK_ZeroInitialization:
+  case SK_ParenthesizedListInit:
     break;
   }
 
   // Promote from an unevaluated context to an unevaluated list context in
   // C++11 list-initialization; we need to instantiate entities usable in
   // constant expressions here in order to perform narrowing checks =(
   EnterExpressionEvaluationContext Evaluated(
       S, EnterExpressionEvaluationContext::InitList,
case SK_OCLZeroOpaqueType: {
               Step->Type->isOCLIntelSubgroupAVCType()) &&
              "Wrong type for initialization of OpenCL opaque type.");
 
       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
                                     CK_ZeroToOCLOpaqueType,
                                     CurInit.get()->getValueKind());
       break;
     }
+    case SK_ParenthesizedListInit: {
+      CurInit = false;
+      TryOrBuildParenListInitialization(S, Entity, Kind, Args, *this,
+                                        /*VerifyOnly=*/false, &CurInit);
+      if (CurInit.get() && ResultType)
+        *ResultType = CurInit.get()->getType();
+      break;
+    }
     }
   }
 
   // Check whether the initializer has a shorter lifetime than the initialized
   // entity, and if not, either lifetime-extend or warn as appropriate.
   if (auto *Init = CurInit.get())
     S.checkInitializerLifetime(Entity, Init);
 
OverloadingResult Ovl
       = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
     (void)Ovl;
     assert(Ovl == OR_Success && "Inconsistent overload resolution");
     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
     S.Diag(CtorDecl->getLocation(),
            diag::note_explicit_ctor_deduction_guide_here) << false;
     break;
   }
+
+  case FK_ParenthesizedListInitFailed:
+    TryOrBuildParenListInitialization(S, Entity, Kind, Args, *this,
+                                      /*VerifyOnly=*/false);
   }
 
   PrintInitLocationNote(S, Entity);
   return true;
 }
 
 void InitializationSequence::dump(raw_ostream &OS) const {
   switch (SequenceKind) {
case FailedSequence: {
 
     case FK_ListConstructorOverloadFailed:
       OS << "list constructor overloading failed";
       break;
 
     case FK_ExplicitConstructor:
       OS << "list copy initialization chose explicit constructor";
       break;
+
+    case FK_ParenthesizedListInitFailed:
+      OS << "parenthesized list initialization failed";
+      break;
     }
     OS << '\n';
     return;
   }
 
   case DependentSequence:
     OS << "Dependent sequence\n";
     return;
for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
 
     case SK_OCLSamplerInit:
       OS << "OpenCL sampler_t from integer constant";
       break;
 
     case SK_OCLZeroOpaqueType:
       OS << "OpenCL opaque type from zero";
       break;
+    case SK_ParenthesizedListInit:
+      OS << "initialization from a parenthesized list of values";
+      break;
     }
 
     OS << " [" << S->Type << ']';
   }
 
   OS << '\n';
 }
 

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
   // then produce a fallback value or error.
   if (Result.isUnset())
     return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
                                                 E->getOperator());
 
   return Result;
 }
 
-template<typename Derived>
+template <typename Derived>
 ExprResult
+TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) {
+  // FIXME: unimplemented
+  llvm_unreachable("unimplemented");
+}
+
+template<typename Derived>
+ExprResult
 TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
     CXXStdInitializerListExpr *E) {
   return getDerived().TransformExpr(E->getSubExpr());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
   E->RParenLoc = readSourceLocation();
   E->NumExpansions = Record.readInt();
   E->SubExprs[0] = Record.readSubExpr();
   E->SubExprs[1] = Record.readSubExpr();
   E->SubExprs[2] = Record.readSubExpr();
   E->Opcode = (BinaryOperatorKind)Record.readInt();
 }
 
+void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
+  VisitExpr(E);
+  E->Loc = readSourceLocation();
+  E->NumExprs = Record.readInt();
+  for (unsigned I = 0; I < E->NumExprs; I++)
+    E->getTrailingObjects<Expr *>()[I] = Record.readSubExpr();
+}
+
 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
   E->SourceExpr = Record.readSubExpr();
   E->OpaqueValueExprBits.Loc = readSourceLocation();
   E->setIsUnique(Record.readInt());
 }
 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {

     case EXPR_MATERIALIZE_TEMPORARY:
       S = new (Context) MaterializeTemporaryExpr(Empty);
       break;
 
     case EXPR_CXX_FOLD:
       S = new (Context) CXXFoldExpr(Empty);
       break;
 
+    case EXPR_CXX_PAREN_LIST_INIT:
+      S = new (Context) CXXParenListInitExpr(Empty);
+      break;
+
     case EXPR_OPAQUE_VALUE:
       S = new (Context) OpaqueValueExpr(Empty);
       break;
 
     case EXPR_CUDA_KERNEL_CALL:
       S = CUDAKernelCallExpr::CreateEmpty(
           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
           /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(EXPR_CXX_DYNAMIC_CAST);
   RECORD(EXPR_CXX_REINTERPRET_CAST);
   RECORD(EXPR_CXX_CONST_CAST);
   RECORD(EXPR_CXX_ADDRSPACE_CAST);
   RECORD(EXPR_CXX_FUNCTIONAL_CAST);
   RECORD(EXPR_USER_DEFINED_LITERAL);
   RECORD(EXPR_CXX_STD_INITIALIZER_LIST);
   RECORD(EXPR_CXX_BOOL_LITERAL);
+  RECORD(EXPR_CXX_PAREN_LIST_INIT);
   RECORD(EXPR_CXX_NULL_PTR_LITERAL);
   RECORD(EXPR_CXX_TYPEID_EXPR);
   RECORD(EXPR_CXX_TYPEID_TYPE);
   RECORD(EXPR_CXX_THIS);
   RECORD(EXPR_CXX_THROW);
   RECORD(EXPR_CXX_DEFAULT_ARG);
   RECORD(EXPR_CXX_DEFAULT_INIT);
   RECORD(EXPR_CXX_BIND_TEMPORARY);

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
   Record.push_back(E->NumExpansions);
   Record.AddStmt(E->SubExprs[0]);
   Record.AddStmt(E->SubExprs[1]);
   Record.AddStmt(E->SubExprs[2]);
   Record.push_back(E->Opcode);
   Code = serialization::EXPR_CXX_FOLD;
 }
 
+void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
+  VisitExpr(E);
+  Record.AddSourceLocation(E->getExprLoc());
+  ArrayRef<Expr *> InitExprs = E->getInitExprs();
+  Record.push_back(InitExprs.size());
+  for (Expr *InitExpr : E->getInitExprs())
+    Record.AddStmt(InitExpr);
+  Code = serialization::EXPR_CXX_PAREN_LIST_INIT;
+}
+
 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
   Record.AddStmt(E->getSourceExpr());
   Record.AddSourceLocation(E->getLocation());
   Record.push_back(E->isUnique());
   Code = serialization::EXPR_OPAQUE_VALUE;
 }
 

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

case Stmt::CXXBindTemporaryExprClass: {
       break;
     }
 
     case Stmt::ArrayInitLoopExprClass:
       Bldr.takeNodes(Pred);
       VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), Pred, Dst);
       Bldr.addNodes(Dst);
       break;
     // Cases not handled yet; but will handle some day.
     case Stmt::DesignatedInitExprClass:
     case Stmt::DesignatedInitUpdateExprClass:
     case Stmt::ArrayInitIndexExprClass:
     case Stmt::ExtVectorElementExprClass:
     case Stmt::ImaginaryLiteralClass:
     case Stmt::ObjCAtCatchStmtClass:
     case Stmt::ObjCAtFinallyStmtClass:
     case Stmt::ObjCAtTryStmtClass:
     case Stmt::ObjCAutoreleasePoolStmtClass:
     case Stmt::ObjCEncodeExprClass:
     case Stmt::ObjCIsaExprClass:
     case Stmt::ObjCProtocolExprClass:
     case Stmt::ObjCSelectorExprClass:
     case Stmt::ParenListExprClass:
     case Stmt::ShuffleVectorExprClass:
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::ConceptSpecializationExprClass:
     case Stmt::CXXRewrittenBinaryOperatorClass:
     case Stmt::RequiresExprClass:
+    case Expr::CXXParenListInitExprClass:
       // Fall through.
 
     // Cases we intentionally don't evaluate, since they don't need
     // to be explicitly evaluated.
     case Stmt::PredefinedExprClass:
     case Stmt::AddrLabelExprClass:
     case Stmt::AttributedStmtClass:
     case Stmt::IntegerLiteralClass:

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

 // RUN: %clang_cc1 -std=c++2a -verify %s -fcxx-exceptions
 
 namespace std {
-  struct strong_ordering { // expected-note 6{{candidate}}
+  struct strong_ordering {
     int n;
     constexpr operator int() const { return n; }
     static const strong_ordering less, equal, greater;
   };
   constexpr strong_ordering strong_ordering::less{-1},
       strong_ordering::equal{0}, strong_ordering::greater{1};
 
   struct weak_ordering {
use(
       Cmp<D2>() <=> Cmp<D2>(), // expected-error {{deleted}}
       Cmp<E>() <=> Cmp<E>(), // expected-error {{deleted}}
       Cmp<F>() <=> Cmp<F>(), // expected-error {{deleted}}
       // FIXME: The following three errors are not very good.
       // expected-error@#cmp {{value of type 'void' is not contextually convertible to 'bool'}}
       Cmp<G1>() <=> Cmp<G1>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}G1>' first required here}}j
       // expected-error@#cmp {{value of type 'void' is not contextually convertible to 'bool'}}
       Cmp<G2>() <=> Cmp<G2>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}G2>' first required here}}j
-      // expected-error@#cmp {{no matching conversion for static_cast from 'void' to 'std::strong_ordering'}}
+      // expected-error@#cmp {{static_cast from 'void' to 'std::strong_ordering' is not allowed}}
       Cmp<H>() <=> Cmp<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}H>' first required here}}j
       0
     );
   }
 
   // expected-note@#arr {{deleted comparison function for member 'arr'}}
   // expected-note@#arr {{no viable three-way comparison function for member 'arr'}}
   // expected-note@#arr {{three-way comparison cannot be synthesized because there is no viable function for '<' comparison}}
use(
       CmpArray<D2>() <=> CmpArray<D2>(), // expected-error {{deleted}}
       CmpArray<E>() <=> CmpArray<E>(), // expected-error {{deleted}}
       CmpArray<F>() <=> CmpArray<F>(), // expected-error {{deleted}}
       // FIXME: The following three errors are not very good.
       // expected-error@#cmparray {{value of type 'void' is not contextually convertible to 'bool'}}
       CmpArray<G1>() <=> CmpArray<G1>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}G1>' first required here}}j
       // expected-error@#cmparray {{value of type 'void' is not contextually convertible to 'bool'}}
       CmpArray<G2>() <=> CmpArray<G2>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}G2>' first required here}}j
-      // expected-error@#cmparray {{no matching conversion for static_cast from 'void' to 'std::strong_ordering'}}
+      // expected-error@#cmparray {{static_cast from 'void' to 'std::strong_ordering' is not allowed}}
       CmpArray<H>() <=> CmpArray<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}H>' first required here}}j
       0
     );
   }
 }
 
 namespace Access {
   class A {

clang/test/CXX/drs/dr2xx.cpp

-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,pre20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,pre20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,pre20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,pre20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,pro20 -fexceptions -fcxx-exceptions -pedantic-errors
 
 // PR13819 -- __SIZE_TYPE__ is incompatible.
 typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
 
 #if __cplusplus < 201103L
 #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
 #else
 #define fold
namespace dr218 { // dr218: yes
 
   struct C {
     int f;
     void test1(A::S as) { f(as); } // expected-error {{called object type 'int'}}
     void test2(A::S as) { void f(); f(as); } // expected-error {{too many arguments}} expected-note {{}}
     void test3(A::S as) { using A::f; f(as); } // ok
     void test4(A::S as) { using B::f; f(as); } // ok
     void test5(A::S as) { int f; f(as); } // expected-error {{called object type 'int'}}
-    void test6(A::S as) { struct f {}; (void) f(as); } // expected-error {{no matching conversion}} expected-note +{{}}
+    void test6(A::S as) { struct f {}; (void) f(as); } // pre20-error {{no matching conversion}} pre20-note +{{}}
+    // pro20-error@-1 {{functional-style cast from 'A::S' to 'f' is not allowed}}
   };
 
   namespace D {
     struct S {};
     struct X { void operator()(S); } f;
   }
   void testD(D::S ds) { f(ds); } // expected-error {{undeclared identifier}}
 

clang/test/CXX/temp/temp.decls/temp.variadic/p4.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
-// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexceptions -fcxx-exceptions -verify=expected,pre20 %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fexceptions -fcxx-exceptions -verify=expected,pro20 %s
 
 template<typename... Types> struct tuple;
 template<int I> struct int_c;
 
 template<typename T>
 struct identity {
   typedef T type;
 };

 // In a base-specifier-list (Clause 10); the pattern is a base-specifier.
 template<typename ...Mixins>
 struct HasMixins : public Mixins... { 
   HasMixins();
   HasMixins(const HasMixins&);
   HasMixins(int i);
 };
 
-struct A { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}} \
-// expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}} \
-// expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
-struct B { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const B' for 1st argument}} \
-// expected-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'B' for 1st argument}} \
-// expected-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+struct A { }; // pre20-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}} \
+// pre20-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}} \
+// pre20-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+struct B { }; // pre20-note{{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const B' for 1st argument}} \
+// pre20-note{{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'B' for 1st argument}} \
+// pre20-note{{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
 struct C { };
 struct D { };
 
 A *checkA = new HasMixins<A, B, C, D>;
 B *checkB = new HasMixins<A, B, C, D>;
 D *checkD = new HasMixins<A, B, C, D>;
 C *checkC = new HasMixins<A, B, D>; // expected-error{{cannot initialize a variable of type 'C *' with an rvalue of type 'HasMixins<A, B, D> *'}}
 HasMixins<> *checkNone = new HasMixins<>;
 
 template<typename Mixins>
 struct BrokenMixins : public Mixins... { }; // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
 
 // In a mem-initializer-list (12.6.2); the pattern is a mem-initializer.
 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(): Mixins()... { }
 
 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(const HasMixins &other): Mixins(other)... { }
 
 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { }
-// expected-error@-1 {{no matching constructor for initialization of 'A'}}
-// expected-error@-2 {{no matching constructor for initialization of 'B'}}
+// pre20-error@-1 {{no matching constructor for initialization of 'A'}}
+// pre20-error@-2 {{no matching constructor for initialization of 'B'}}
+// pro20-error@-3 {{excess elements in struct initializer}}
+// pro20-error@-4 {{excess elements in struct initializer}}
 
 void test_has_mixins() {
   HasMixins<A, B> ab;
   HasMixins<A, B> ab2 = ab;
   HasMixins<A, B> ab3(17); // expected-note{{in instantiation of member function 'HasMixins<A, B>::HasMixins' requested here}}
 }
 
 template<typename T>

clang/test/CodeGen/P0960R3.cpp

+// RUN: %clang_cc1 -std=c++20 %s -emit-llvm -triple x86_64-unknown-linux-gnu -o - | FileCheck %s
+
+// CHECK-DAG: [[STRUCT_A:%.*]] = type { i8, double }
+struct A {
+  char i;
+  double j;
+};
+
+// CHECK-DAG: [[STRUCT_B:%.*]] = type { [[STRUCT_A]], i32 }
+struct B {
+  A a;
+  int b;
+};
+
+// CHECK-DAG: [[STRUCT_C:%.*]] = type <{ [[STRUCT_B]], [[STRUCT_A]], i32, [4 x i8] }>
+struct C : public B, public A {
+  int c;
+};
+
+// CHECK-DAG: [[STRUCT_D:%.*]] = type { [[STRUCT_A]], [[STRUCT_A]], i8, [[STRUCT_A]] }
+struct D {
+  A a;
+  A b = A{2, 2.0};
+  unsigned : 2;
+  A c;
+};
+
+// CHECK-DAG: [[UNION_U:%.*]] = type { [[STRUCT_A]] }
+union U {
+  unsigned : 1;
+  A a;
+  char b;
+};
+
+// CHECK-DAG: [[A1:@.*a1.*]] = internal constant [[STRUCT_A]] { i8 3, double 2.000000e+00 }, align 8
+constexpr A a1(3.1, 2.0);
+// CHECK-DAG: [[B1:@.*b1.*]] = internal constant [[STRUCT_B]] { [[STRUCT_A]] { i8 99, double 0.000000e+00 }, i32 0 }, align 8
+constexpr B b1(A('c'));
+// CHECK-DAG: [[C1:@.*c1.*]] = internal constant { [[STRUCT_A]], i32, [4 x i8], i8, double, i32 } { [[STRUCT_A]] { i8 99, double 0.000000e+00 }, i32 0, [4 x i8] undef, i8 3, double 2.000000e+00, i32 0 }, align
+constexpr C c1(b1, a1);
+// CHECK-DAG: [[U1:@.*u1.*]] = internal constant [[UNION_U]] { [[STRUCT_A]] { i8 1, double 1.000000e+00 } }, align 8
+constexpr U u1(A(1, 1));
+// CHECK-DAG: [[D1:@.*d1.*]] = internal constant { [[STRUCT_A]], [[STRUCT_A]], [8 x i8], [[STRUCT_A]] } { [[STRUCT_A]] { i8 2, double 2.000000e+00 }, [[STRUCT_A]] { i8 2, double 2.000000e+00 }, [8 x i8] undef, [[STRUCT_A]] zeroinitializer }, align 8
+constexpr D d1(A(2, 2));
+// CHECK-DAG: [[ARR1:@.*arr1.*]] = internal constant [3 x i32] [i32 1, i32 2, i32 0], align 4
+constexpr int arr1[3](1, 2);
+
+// CHECK: define dso_local { i8, double } @{{.*foo1.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[RETVAL:%.*]] = alloca [[STRUCT_A]], align 8
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[A1]], i64 16, i1 false)
+// CHECK-NEXT: [[TMP_0:%.*]] = load { i8, double }, ptr [[RETVAL]], align 8
+// CHECK-NEXT: ret { i8, double } [[TMP_0]]
+A foo1() {
+  return a1;
+}
+
+// CHECK: define dso_local void @{{.*foo2.*}}(ptr noalias sret([[STRUCT_B]]) align 8 [[AGG_RESULT:%.*]])
+// CHECK-NEXT: entry:
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[AGG_RESULT]], ptr align 8 [[B1]], i64 24, i1 false)
+// CHECK-NEXT: ret void
+B foo2() {
+  return b1;
+}
+
+// CHECK: define dso_local void @{{.*foo3.*}}(ptr noalias sret([[STRUCT_C]]) align 8 [[AGG_RESULT:%.*]])
+// CHECK-NEXT: entry:
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[AGG_RESULT]], ptr align 8 [[C1]], i64 48, i1 false)
+// CHECK-NEXT: ret void
+C foo3() {
+  return c1;
+}
+
+// CHECK: define dso_local void @{{.*foo4.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[C2:%.*]] = alloca [[STRUCT_C:%.*]], align 8
+// CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_B:%.*]], align 8
+// CHECK-NEXT: [[REF_TMP_1:%.*]] = alloca [[STRUCT_A:%.*]], align 8
+// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[STRUCT_B]], ptr [[REF_TMP]], i32 0, i32 0
+// CHECK-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[A]], i32 0, i32 0
+// CHECK-NEXT: store i8 1, ptr [[I]], align 8
+// CHECK-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[A]], i32 0, i32 1
+// CHECK-NEXT: store double 1.000000e+00, ptr [[J]], align 8
+// CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [[STRUCT_B]], ptr [[REF_TMP]], i32 0, i32 1
+// CHECK-NEXT: store i32 1, ptr [[B]], align 8
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[C2]], ptr align 8 [[REF_TMP]], i64 24, i1 false)
+// CHECK-NEXT: [[TMP_0:%.*]] = getelementptr inbounds i8, ptr [[C2]], i64 24
+// CHECK-NEXT: [[I2:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[REF_TMP_1]], i32 0, i32 0
+// CHECK-NEXT: store i8 97, ptr [[I2]], align 8
+// CHECK-NEXT: [[J3:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[REF_TMP_1]], i32 0, i32 1
+// CHECK-NEXT: store double 0.000000e+00, ptr [[J3]], align 8
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[TMP_0]], ptr align 8 [[REF_TMP_1]], i64 16, i1 false)
+// CHECK-NEXT: [[C:%.*]] = getelementptr inbounds %struct.C, ptr %c2, i32 0, i32 2
+// CHECK-NEXT: store i32 2, ptr %c, align 8
+// CHECK-NEXT: ret void
+void foo4() {
+  C c2(B(A(1, 1), 1), A('a'), 2);
+}
+
+// CHECK: define dso_local { i64, double } @{{.*foo5.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT [[RETVAL:%.*]] = alloca [[UNION_U]], align 8
+// CHECK-NEXT call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[U1]], i64 16, i1 false)
+// CHECK-NEXT [[COERCE_DIVE:%.*]] = getelementptr inbounds [[UNION_U]], ptr %retval, i32 0, i32 0
+// CHECK-NEXT [[TMP_0:%.*]] = load { i64, double }, ptr [[COERCE_DIVE]], align 8
+// CHECK-NEXT ret { i64, double } [[TMP_0]]
+U foo5() {
+  return u1;
+}
+
+
+// CHECK: define dso_local { i64, double } @{{.*foo6.*}}(i8 [[A_COERCE_0:%.*]], double [[A_COERCE_1:%.*]])
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[RETVAL:%.*]] = alloca [[UNION_U]], align 8
+// CHECK-NEXT:   [[A:%.*]] = alloca [[STRUCT_A]], align 8
+// CHECK-NEXT:   [[TMP_0:%.*]] = getelementptr inbounds { i8, double }, ptr [[A]], i32 0, i32 0
+// CHECK-NEXT:   store i8 [[A_COERCE_0]], ptr [[TMP_0]], align 8
+// CHECK-NEXT:   [[TMP_1:%.*]] = getelementptr inbounds { i8, double }, ptr [[A]], i32 0, i32 1
+// CHECK-NEXT:   store double [[A_COERCE_1]], ptr [[TMP_1]], align 8
+// CHECK-NEXT:   call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[A]], i64 16, i1 false)
+// CHECK-NEXT:   [[COERCE_DIVE:%.*]] = getelementptr inbounds [[UNION_U]], ptr [[RETVAL]], i32 0, i32 0
+// CHECK-NEXT:   [[TMP_2:%.*]] = load { i64, double }, ptr [[COERCE_DIVE:%.*]], align 8
+// CHECK-NEXT:   ret { i64, double } [[TMP_2]]
+U foo6(A a) {
+  return U(a);
+}
+
+// CHECK: define dso_local void @{{.*foo7.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[D:%.*]] = alloca [[STRUCT_D:%.*]], align 8
+// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 0
+// CHECK-NEXT: [[I]] = getelementptr inbounds [[STRUCT_A:%.*]], ptr [[A]], i32 0, i32 0
+// CHECK-NEXT: store i8 1, ptr [[I]], align 8
+// CHECK-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[A]], i32 0, i32 1
+// CHECK-NEXT: store double 1.000000e+00, ptr [[J]], align 8
+// CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 1
+// CHECK-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[B]], i32 0, i32 0
+// CHECK-NEXT: store i8 11, ptr [[I1]], align 8
+// CHECK-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[B]], i32 0, i32 1
+// CHECK-NEXT: store double 1.100000e+01, ptr [[J2]], align 8
+// CHECK-NEXT: [[C:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 3
+// CHECK-NEXT: [[I3:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[C]], i32 0, i32 0
+// CHECK-NEXT: store i8 111, ptr [[I3]], align 8
+// CHECK-NEXT: [[J4:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[C]], i32 0, i32 1
+// CHECK-NEXT: store double 1.110000e+02, ptr [[J4]], align 8
+// CHECK-NEXT: ret void
+void foo7() {
+  D d(A(1, 1), A(11, 11), A(111, 111));
+}
+
+// CHECK: dso_local void @{{.*foo8.*}}(ptr noalias sret([[STRUCT_D]]) align 8 [[AGG_RESULT:%.*]])
+// CHECK-NEXT: entry:
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[AGG_RESULT]], ptr align 8 [[D1]], i64 56, i1 false)
+// CHECK-NEXT: ret void
+D foo8() {
+  return d1;
+}
+
+// CHECK: define dso_local void @{{.*foo9.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[D:%.*]] = alloca [[STRUCT_D:%.*]], align 8
+// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 0
+// CHECK-NEXT: [[I]] = getelementptr inbounds [[STRUCT_A:%.*]], ptr [[A]], i32 0, i32 0
+// CHECK-NEXT: store i8 1, ptr [[I]], align 8
+// CHECK-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[A]], i32 0, i32 1
+// CHECK-NEXT: store double 1.000000e+00, ptr [[J]], align 8
+// CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 1
+// CHECK-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[B]], i32 0, i32 0
+// CHECK-NEXT: store i8 2, ptr [[I1]], align 8
+// CHECK-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_A]], ptr [[B]], i32 0, i32 1
+// CHECK-NEXT: store double 2.000000e+00, ptr [[J2]], align 8
+// CHECK-NEXT: [[C:%.*]] = getelementptr inbounds [[STRUCT_D]], ptr [[D]], i32 0, i32 3
+// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[C]], i8 0, i64 16, i1 false)
+// CHECK-NEXT: ret void
+void foo9() {
+  D d(A(1, 1));
+}
+
+// CHECK: define dso_local noundef ptr @{{.*foo10.*}}()
+// CHECK-NEXT: entry:
+// CHECK-NEXT: ret ptr [[ARR1]]
+const int* foo10() {
+  return arr1;
+}
+
+// CHECK: define dso_local void @{{.*foo11.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[A_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT: [[B_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT: [[ARR_2:%.*]] = alloca [3 x i32], align 4
+// CHECK-NEXT: [[ARR_3:%.*]] = alloca [2 x i32], align 4
+// CHECK-NEXT: store i32 [[A:%.*]], ptr [[A_ADDR]], align 4
+// CHECK-NEXT: store i32 [[B:%.*]], ptr [[B_ADDR]], align 4
+// CHECK-NEXT: [[TMP_0:%.*]] = getelementptr inbounds [3 x i32], ptr [[ARR_2]], i64 0, i64 0
+// CHECK-NEXT: [[TMP_1:%.*]] = load i32, ptr [[A_ADDR]], align 4
+// CHECK-NEXT: store i32 [[TMP_1]], ptr [[TMP_0]], align 4
+// CHECK-NEXT: [[TMP_2:%.*]] = getelementptr inbounds [3 x i32], ptr [[ARR_2]], i64 0, i64 1
+// CHECK-NEXT: [[TMP_3:%.*]] = load i32, ptr [[B_ADDR]], align 4
+// CHECK-NEXT: store i32 [[TMP_3]], ptr [[TMP_2]], align 4
+// CHECK-NEXT: [[TMP_4:%.*]] = getelementptr inbounds [3 x i32], ptr [[ARR_2]], i64 0, i64 2
+// CHECK-NEXT: store i32 0, ptr [[TMP_4]], align 4
+// CHECK-NEXT: [[TMP_5:%.*]] = getelementptr inbounds [2 x i32], ptr [[ARR_3]], i64 0, i64 0
+// CHECK-NEXT: [[TMP_6:%.*]] = load i32, ptr [[A_ADDR]], align 4
+// CHECK-NEXT: store i32 [[TMP_6]], ptr [[TMP_5]], align 4
+// CHECK-NEXT: [[TMP_7:%.*]] = getelementptr inbounds [2 x i32], ptr [[ARR_3]], i64 0, i64 1
+// CHECK-NEXT: [[TMP_8:%.*]] = load i32, ptr [[B_ADDR]], align 4
+// CHECK-NEXT: store i32 [[TMP_8]], ptr [[TMP_7]], align 4
+// CHECK-NEXT: ret void
+void foo11(int a, int b) {
+  int arr2[3](a, b);
+  int arr3[](a, b);
+}

clang/test/SemaCXX/P0960R3.cpp

+// RUN: %clang_cc1 -verify -std=c++20 %s -fsyntax-only
+
+struct A { // expected-note 4{{candidate constructor}}
+  char i;
+  double j;
+};
+
+struct B {
+  A a;
+  int b[20];
+  int &&c; // expected-note {{reference member declared here}}
+};
+
+struct C { // expected-note 2{{candidate constructor}}
+  A a;
+  int b[20];
+};
+
+struct D : public C, public A {
+  int a;
+};
+
+struct E { // expected-note 3{{candidate constructor}}
+  struct F {
+    F(int, int);
+  };
+  int a;
+  F f;
+};
+
+int getint(); // expected-note {{declared here}}
+
+struct F {
+  int a;
+  int b = getint(); // expected-note {{non-constexpr function 'getint' cannot be used in a constant expression}}
+};
+
+union U {
+  int a;
+  char* b;
+};
+
+void foo() {
+  A a(1954, 9, 21);
+  // expected-error@-1 {{excess elements in struct initializer}}
+  A b(2.1);
+  // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
+  A e(-1.2, 9.8);
+  // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
+  A s = static_cast<A>(1.1);
+  // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
+  A h = (A)3.1;
+  // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
+  A i = A(8.7);
+  // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
+
+  B n(2022, {7, 8});
+  // expected-error@-1 {{no viable conversion from 'int' to 'A'}}
+  B z(A(1), {}, 1);
+  // expected-error@-1 {{reference member 'c' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+
+  C o(A(1), 1, 2, 3, 4);
+  // expected-error@-1 {{excess elements in struct initializer}}
+  D R(1);
+  // expected-error@-1 {{no viable conversion from 'int' to 'C'}}
+  D I(C(1));
+  // expected-error@-1 {{functional-style cast from 'int' to 'C' is not allowed}}
+  D P(C(A(1)), 1);
+  // expected-error@-1 {{no viable conversion from 'int' to 'A'}}
+
+  int arr1[](0, 1, 2, A(1));
+  // expected-error@-1 {{no viable conversion from 'A' to 'int'}}
+  int arr2[2](0, 1, 2);
+  // expected-error@-1 {{excess elements in array initializer}}
+
+  U u1("abcd");
+  // expected-error@-1 {{cannot initialize a member subobject of type 'int' with an lvalue of type 'const char[5]'}}
+  U u2(1, "efgh");
+  // expected-error@-1 {{excess elements in union initializer}}
+
+  E e1(1);
+  // expected-error@-1 {{no matching constructor for initialization of 'E'}}
+
+  constexpr F f1(1);
+  // expected-error@-1 {{constexpr variable 'f1' must be initialized by a constant expression}}
+
+  constexpr F f2(1, 1); // OK: f2.b is initialized by a constant expression.
+}

clang/test/SemaCXX/cxx2a-explicit-bool.cpp

-// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify -Wno-c++2a-extensions
-// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify=expected,pre20 -Wno-c++2a-extensions
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify=expected,pro20
 
 template <bool b, auto val> struct enable_ifv {};
 
 template <auto val> struct enable_ifv<true, val> {
   static constexpr auto value = val;
 };
 
 template <typename T1, typename T2> struct is_same {
   static constexpr bool value = false;
 };
 
 template <typename T> struct is_same<T, T> {
   static constexpr bool value = true;
 };
 
 namespace special_cases
 {
 
 template<int a>
 struct A {
-// expected-note@-1+ {{candidate constructor}}
+// pre20-note@-1+ {{candidate constructor}}
   explicit(1 << a)
 // expected-note@-1 {{negative shift count -1}}
 // expected-error@-2 {{explicit specifier argument is not a constant expression}}
   A(int);
 };
 
 A<-1> a(0);
-// expected-error@-1 {{no matching constructor}}
-// expected-note@-2 {{in instantiation of template class}}
+// pre20-error@-1 {{no matching constructor}}
+// pro20-error@-2 {{excess elements in struct initializer}}
+// expected-note@-3 {{in instantiation of template class}}
 
 template<int a>
 struct B {
   explicit(b)
   // expected-error@-1 {{use of undeclared identifier}}
   B(int);
 };
 

clang/tools/libclang/CIndex.cpp

public:
   void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
   void VisitVAArgExpr(const VAArgExpr *E);
   void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
   void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
   void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
   void VisitLambdaExpr(const LambdaExpr *E);
   void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
   void VisitRequiresExpr(const RequiresExpr *E);
+  void VisitCXXParenListInitExpr(const CXXParenListInitExpr *E);
   void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
   void VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *D);
   void VisitOMPLoopDirective(const OMPLoopDirective *D);
   void VisitOMPParallelDirective(const OMPParallelDirective *D);
   void VisitOMPSimdDirective(const OMPSimdDirective *D);
   void
   VisitOMPLoopTransformationDirective(const OMPLoopTransformationDirective *D);
   void VisitOMPTileDirective(const OMPTileDirective *D);
void EnqueueVisitor::VisitConceptSpecializationExpr(
     const ConceptSpecializationExpr *E) {
   WL.push_back(ConceptSpecializationExprVisit(E, Parent));
 }
 void EnqueueVisitor::VisitRequiresExpr(const RequiresExpr *E) {
   WL.push_back(RequiresExprVisit(E, Parent));
   for (ParmVarDecl *VD : E->getLocalParameters())
     AddDecl(VD);
 }
+void EnqueueVisitor::VisitCXXParenListInitExpr(const CXXParenListInitExpr *E) {
+  EnqueueChildren(E);
+}
 void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
   // Treat the expression like its syntactic form.
   Visit(E->getSyntacticForm());
 }
 
 void EnqueueVisitor::VisitOMPExecutableDirective(
     const OMPExecutableDirective *D) {
   EnqueueChildren(D);
CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_ObjCMessageExpr:
     return cxstring::createRef("ObjCMessageExpr");
   case CXCursor_BuiltinBitCastExpr:
     return cxstring::createRef("BuiltinBitCastExpr");
   case CXCursor_ConceptSpecializationExpr:
     return cxstring::createRef("ConceptSpecializationExpr");
   case CXCursor_RequiresExpr:
     return cxstring::createRef("RequiresExpr");
+  case CXCursor_CXXParenListInitExpr:
+    return cxstring::createRef("CXXParenListInitExpr");
   case CXCursor_UnexposedStmt:
     return cxstring::createRef("UnexposedStmt");
   case CXCursor_DeclStmt:
     return cxstring::createRef("DeclStmt");
   case CXCursor_LabelStmt:
     return cxstring::createRef("LabelStmt");
   case CXCursor_CompoundStmt:
     return cxstring::createRef("CompoundStmt");

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::ConceptSpecializationExprClass:
     K = CXCursor_ConceptSpecializationExpr;
     break;
 
   case Stmt::RequiresExprClass:
     K = CXCursor_RequiresExpr;
     break;
 
+  case Stmt::CXXParenListInitExprClass:
+    K = CXCursor_CXXParenListInitExpr;
+    break;
+
   case Stmt::MSDependentExistsStmtClass:
     K = CXCursor_UnexposedStmt;
     break;
   case Stmt::OMPCanonicalLoopClass:
     K = CXCursor_OMPCanonicalLoop;
     break;
   case Stmt::OMPMetaDirectiveClass:
     K = CXCursor_OMPMetaDirective;