[c++2b] Implement P0849R8 auto(x)

[lichray]

Summary

https://wg21.link/p0849

[lichray]

Document updates

[lichray]

C++2y -> C++2b

[lichray]

Clang-format

[rsmith]

Thanks, this generally looks great.

It looks like we'll need some additional work on disambiguation to handle cases like:

struct A { int n; } a;
void f() { auto(&a)->n = 0; }

I think that's valid, but right now we misparse it as a declaration of a variable &a. (This syntax also resembles a function declaration with a trailing return type, but that interpretation should be rejected for various reasons, such as because n isn't a type.) This disambiguation failure seems to be specific to auto; this similar case is parsed properly:

struct A { int n; } a;
using T = A*;
void f() { T(&a)->n = 1; }

clang/lib/Parse/ParseDeclCXX.cpp

1035

Nice catch :)

clang/lib/Sema/SemaExprCXX.cpp

1482

Please use an explicit type here.

1483–1487

You should only do this if ListInitialization is true. Otherwise we'll accept the invalid syntax auto({a}).

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

20

We're missing a test that we reject auto({a}). I assume that's what this line was intended to do.

[rsmith]

I also wonder whether we should accept decltype(auto)(x) as an extension, but we can discuss that separately.

[• Quuxplusone]

Comments on tests.

clang/lib/Parse/ParseDeclCXX.cpp

1035

I see zero hits for git grep 'decltype[(]auto[^)] clang/. So it seems this corner of the grammar has been missing any tests for a long time, but I hope this PR will add some.

decltype(auto*) i = 42; // should be a syntax error
decltype(auto(42)) i = 42;  // should be OK 
decltype(auto()) i = 42;  // should be a syntax error

Right now I don't see any tests for this stuff in this PR either. So it needs some.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

7–29

It is definitely a good idea to repeat all of these tests with braces too: auto{v}, auto{"lit"}, etc.

52

Should you check that __is_same(decltype(auto(*this)), A)?
Should you check that __is_same(decltype(auto(this)), A*)?
Should you test inside a const member function too?
Should you check that the friend function actually can call auto(some_a_object), the same way it can call A(some_a_object) — and more to the point, that a non-friend can't?

57

I'm not sure which test file it should go in, but you definitely want a test somewhere proving that auto doesn't copy prvalues. E.g.

struct Uncopyable {
    explicit Uncopyable(int);
    Uncopyable(Uncopyable&&) = delete;
};
Uncopyable u = auto(Uncopyable(auto(Uncopyable(42))));

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

18–19

What is the significance of the whitespace here? Is this a lexer test?
Normally it'd be just auto(a), auto{a} — just like T(a), T{a}. I think we should follow convention (again, unless this is a lexer test — in which case we should probably test both syntaxes with and without whitespace).

26

I'd also check auto{1,2} (ill-formed, does not deduce initializer_list<int>) and auto{{1,2}} (also ill-formed).

[rsmith]

clang/lib/Parse/ParseDeclCXX.cpp

1035

Some of this is tested in the new file test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp (you might need to expand it manually; full-page search for decltype(auto( might otherwise not find it). It looks like we are missing tests for things like decltype(auto*). It's not obvious to me what diagnostic would be most useful if decltype(auto is not followed by ), (, or {, but my guess is that "expected )" pointing at the *, rather than an error on the auto token, would be the least surprising. So maybe this should be

if (Tok.is(tok::kw_auto) && NextToken().isNot(tok::l_paren, tok::l_brace)) {

?

[lichray]

clang/lib/Parse/ParseDeclCXX.cpp

1035

The r0 patch makes decltype(auto *) diagnose in the same way decltype(long *) do; looks good enough to me.

clang/lib/Sema/SemaExprCXX.cpp

1483–1487

My bad. Deemed new auto({a}) as valid; now corrected.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

52

All good ideas.

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

18–19

Blame clang-format :/

[lichray]

Address review comments

• more test cases
• render auto({}) and new auto({}) invalid
• disambiguate auto(x)->n that looks like a declaration

[lichray]

• Manually adjust auto{x} formatting

[lichray]

• Implement decltype(auto)(x) as well

[lichray]

In D113393#3128835, @rsmith wrote:

It looks like we'll need some additional work on disambiguation to handle cases like:

struct A { int n; } a;
void f() { auto(&a)->n = 0; }

I think that's valid, but right now we misparse it as a declaration of a variable &a. [...]:

struct A { int n; } a;
using T = A*;
void f() { T(&a)->n = 1; }

Solved the issue and added test cases.

[lichray]

In D113393#3128840, @rsmith wrote:

I also wonder whether we should accept decltype(auto)(x) as an extension, but we can discuss that separately.

Implemented. To produce a reference rather than a temporary, I had to special-case it, but in the end, it costs fewer lines of diff.

[lichray]

Ping. Please review.

• Reformat code after clang-format lands D114519

[rsmith]

Generally this looks good. In addition to the ExtWarn for the decltype(auto) case, I think we're also missing a -Wc++20-compat warning for the feature as a whole.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

5

We should produce an ExtWarn for this case.

[lichray]

• revert the tentative parsing fix
• warn in -Wpre-c++2b-compat and -Wdecltype-auto-cast (ExtWarn)

[lichray]

I reverted the attempt to fix auto(&a)->n = 0; in this revision. The fix is definitely not 3 lines and does not fit in this patch.
Long story short, our tentative parsing code does not look at trailing return types and fails to disambiguate template <class T> void e(auto (*p)(T y) -> decltype(y())) {} if it is still ambiguous after seen auto (. The following files have more interesting cases:

CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p2.cpp
CXX/dcl/dcl.fct/p17.cpp
CodeGenCXX/mangle-exprs.cpp
Parser/cxx0x-ambig.cpp
Parser/cxx1z-decomposition.cpp
SemaCXX/trailing-return-0x.cpp
SemaTemplate/alias-templates.cpp

and not all of them are correct. It needs a closer look in a future issue.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

5

Fixed. Now silenced in this file and produced somewhere else.

[• Quuxplusone]

Am I seeing correctly that there's no feature-test macro for auto(x)?

I'm proposing to introduce #define _LIBCPP_AUTO_CAST(expr) into libc++, so that we can use it for Ranges things that specify in terms of auto(x)... but if I want to make it conditionally expand into auto(x) on compilers that support the feature, I basically have to check the compiler vendor and version number? No feature-test macro?

[lichray]

In D113393#3190788, @Quuxplusone wrote:

Am I seeing correctly that there's no feature-test macro for auto(x)?

Oh, no, there isn't, and there wasn't a __cpp_auto either. I'll open a core issue.

I basically have to check the compiler vendor and version number? No feature-test macro?

For now, yes...

[lichray]

Rebased

[lichray]

• Retarget Clang 15

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

2391

Is there a reason this one should be ExtWarn instead of Extension? (I think we typically only issue this kind of diagnostic when -pedantic is specified.)

clang/lib/Parse/ParseDeclCXX.cpp

1035

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

5

We should produce an ExtWarn for this case.

Can you help me understand our rule for when to use ExtWarn vs Extension for this? I was under the impression we used Extension for this sort of thing, and only used ExtWarn in the cases where the use of the extension is wrong and the warning should be on by default.

[lichray]

• Rephrase a warning message

[lichray]

clang/include/clang/Basic/DiagnosticSemaKinds.td

2391

I took a look at other warnings. It seems that Clang believes that a portable program can contain Extensions; if ExtWarn is issued, the program is not likely to be portable.

I asked GCC folks yesterday to see if they want to implement this extension, and they are not interested. So I guess ExtWarn is suitable for now.

[aaron.ballman]

I spotted some test coverage that I think we should add:

static_cast<auto>(whatever);
reinterpret_cast<auto>(whatever);
const_cast<auto>(whatever);
dynamic_cast<auto>(whatever);
(auto)whatever;

I believe all of those should be rejected because of https://eel.is/c++draft/dcl.spec.auto#general-5.sentence-2.

Are there changes needed for the AST printer for this new form of cast notation?

I suppose one other question worth asking: if we're allowing decltype(auto)(whatever) as a Clang extension, should we be accepting __typeof__(auto)(whatever) as well?

clang/include/clang/Basic/DiagnosticSemaKinds.td

2391

Thanks! I think ExtWarn is fine based on that.

[lichray]

• Add more tests to diagnose other forms of casts

[lichray]

In D113393#3340878, @aaron.ballman wrote:

I spotted some test coverage that I think we should add:

static_cast<auto>(whatever);
reinterpret_cast<auto>(whatever);
const_cast<auto>(whatever);
dynamic_cast<auto>(whatever);
(auto)whatever;

Done.

Are there changes needed for the AST printer for this new form of cast notation?

Wow, I broke AST print. CTAD works in expressions and new because their specializations are valid type-ids...

I suppose one other question worth asking: if we're allowing decltype(auto)(whatever) as a Clang extension, should we be accepting __typeof__(auto)(whatever) as well?

We don't allow __typeof__(auto) type-specifier at the moment, so not yet. I think it may be more reasonable to allow both __typeof__(auto) and typeof(auto) when implementing C23 typeof. Their expression forms should be useful in C++.

[lichray]

• Do not overwrite braced inits when forming AST
• Explain why losing decltype(auto) as written in AST

[aaron.ballman]

Also implemented decltype(auto)(x) (https://wg21.link/p0849r2) as a Clang extension.

I'd like to better understand the use cases for this. WG21 considered this as part of the feature and ultimately rejected it (fairly strongly, according to the EWG polls). From the meeting minutes, it says that the reason EWG disliked the idea is because of its expert-friendly nature and that this facility would present teachability issues. I tend to agree, so I'm wondering why we want to add the feature as an extension when WG21 explicitly rejected it (that doesn't seem in line with our extension policy: https://clang.llvm.org/get_involved.html#criteria).

[• Quuxplusone]

In D113393#3345275, @aaron.ballman wrote:

Also implemented decltype(auto)(x) (https://wg21.link/p0849r2) as a Clang extension.

I'd like to better understand the use cases for this. WG21 considered this as part of the feature and ultimately rejected it (fairly strongly, according to the EWG polls). From the meeting minutes, it says that the reason EWG disliked the idea is because of its expert-friendly nature and that this facility would present teachability issues. I tend to agree, so I'm wondering why we want to add the feature as an extension when WG21 explicitly rejected it (that doesn't seem in line with our extension policy: https://clang.llvm.org/get_involved.html#criteria).

(I'm not directly answering Aaron's question.) Personally I think it makes sense to support decltype(auto)(x) in the same release as auto(x), for the same reason we supported Constrained decltype(auto) in the same release as Constrained auto. But, rather than have that essentially tangential policy discussion in this PR, @lichray, would you be willing to split out all the changes related to decltype(auto)(x) into their own separate PR, (1) so that we could land the uncontroversial C++20 auto(x) parts sooner rather than later, and (2) so that if three years from now someone does decide to revert decltype(auto)(x), all its changes will be nicely isolated in their own commit instead of mixed in with important bits of our C++20 conformance? And (3) so that we could have the "Should we do this?" policy discussion in that PR, instead of here, and (4) the discussion would be more focused because we could see exactly the set of diffs we're talking about, instead of mixed in etc etc.

[aaron.ballman]

In D113393#3345672, @Quuxplusone wrote:

In D113393#3345275, @aaron.ballman wrote:

Also implemented decltype(auto)(x) (https://wg21.link/p0849r2) as a Clang extension.

I'd like to better understand the use cases for this. WG21 considered this as part of the feature and ultimately rejected it (fairly strongly, according to the EWG polls). From the meeting minutes, it says that the reason EWG disliked the idea is because of its expert-friendly nature and that this facility would present teachability issues. I tend to agree, so I'm wondering why we want to add the feature as an extension when WG21 explicitly rejected it (that doesn't seem in line with our extension policy: https://clang.llvm.org/get_involved.html#criteria).

(I'm not directly answering Aaron's question.) Personally I think it makes sense to support decltype(auto)(x) in the same release as auto(x), for the same reason we supported Constrained decltype(auto) in the same release as Constrained auto. But, rather than have that essentially tangential policy discussion in this PR, @lichray, would you be willing to split out all the changes related to decltype(auto)(x) into their own separate PR, (1) so that we could land the uncontroversial C++20 auto(x) parts sooner rather than later, and (2) so that if three years from now someone does decide to revert decltype(auto)(x), all its changes will be nicely isolated in their own commit instead of mixed in with important bits of our C++20 conformance? And (3) so that we could have the "Should we do this?" policy discussion in that PR, instead of here, and (4) the discussion would be more focused because we could see exactly the set of diffs we're talking about, instead of mixed in etc etc.

This option sounds quite sensible to me!

[cor3ntin]

This option sounds quite sensible to me!

I'd like that too!

[lichray]

• Remove decltype(auto) from the patch
• Parenthesize deduced casts in AST print

[lichray]

In D113393#3340878, @aaron.ballman wrote:

Are there changes needed for the AST printer for this new form of cast notation?

Fixed one pre-existing issue, and now emit legal C++ code, except in one corner case. But CXXUnresolvedConstructExpr is a cause of more problems than that, so not touching it for now. Fixed the remaining issues in D120608.

[lichray]

Rebase

[lichray]

Re-run build

[aaron.ballman]

The changes here LGTM, but I'd appreciate a second set of eyes on it in case I missed anything before this lands.

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp

60

[erichkeane]

Just did a pass through, nothing suspicious, I think this looks good.

Mild preference to merge 2 or 3 diagnostics based on how similar they all are, but that can be done without further review, or as a separate commit (or not at all, if no one else cares).

clang/include/clang/Basic/DiagnosticSemaKinds.td

2327

Mild preference to merge at least 2 of these 3 diagnostics.

[lichray]

Use the right copy of clang-format

clang/docs/ReleaseNotes.rst

 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Implemented `P2128R6: Multidimensional subscript operator <https://wg21.link/P2128R6>`_.
+- Implemented `P0849R8: auto(x): decay-copy in the language <https://wg21.link/P0849R8>`_.
 
 CUDA Language Changes in Clang
 ------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------
 
 OpenCL C Language Changes in Clang

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_auto_var_requires_init : Error<
   "declaration of variable %0 with deduced type %1 requires an initializer">;
 def err_auto_new_requires_ctor_arg : Error<
   "new expression for type %0 requires a constructor argument">;
 def ext_auto_new_list_init : Extension<
   "ISO C++ standards before C++17 do not allow new expression for "
   "type %0 to use list-initialization">, InGroup<CXX17>;
 def err_auto_var_init_no_expression : Error<
   "initializer for variable %0 with type %1 is empty">;
+def err_auto_expr_init_no_expression : Error<
+  "initializer for functional-style cast to %0 is empty">;
 def err_auto_var_init_multiple_expressions : Error<
   "initializer for variable %0 with type %1 contains multiple expressions">;
+def err_auto_expr_init_multiple_expressions : Error<
+  "initializer for functional-style cast to %0 contains multiple expressions">;
 def err_auto_var_init_paren_braces : Error<
   "cannot deduce type for variable %1 with type %2 from "
   "%select{parenthesized|nested}0 initializer list">;
 def err_auto_new_ctor_multiple_expressions : Error<
   "new expression for type %0 contains multiple constructor arguments">;
+def err_auto_expr_init_paren_braces : Error<
+  "cannot deduce actual type for %1 from "
+  "%select{parenthesized|nested}0 initializer list">;
+def warn_cxx20_compat_auto_expr : Warning<
+  "'auto' as a functional-style cast is incompatible with C++ standards "
+  "before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore;
 def err_auto_missing_trailing_return : Error<
   "'auto' return without trailing return type; deduced return types are a "
   "C++14 extension">;
 def err_deduced_return_type : Error<
   "deduced return types are a C++14 extension">;
 def err_trailing_return_without_auto : Error<
   "function with trailing return type must specify return type 'auto', not %0">;
 def err_trailing_return_in_parens : Error<
   "trailing return type may not be nested within parentheses">;
 def err_auto_var_deduction_failure : Error<
   "variable %0 with type %1 has incompatible initializer of type %2">;
 def err_auto_var_deduction_failure_from_init_list : Error<
   "cannot deduce actual type for variable %0 with type %1 from initializer list">;
+def err_auto_expr_deduction_failure : Error<
+  "functional-style cast to %0 has incompatible initializer of type %1">;
 def err_auto_new_deduction_failure : Error<
   "new expression for type %0 has incompatible constructor argument of type %1">;
 def err_auto_inconsistent_deduction : Error<
   "deduced conflicting types %diff{($ vs $) |}0,1"
   "for initializer list element type">;
 def err_auto_different_deductions : Error<
   "%select{'auto'|'decltype(auto)'|'__auto_type'|template arguments}0 "
   "deduced as %1 in declaration of %2 and "

 def err_decltype_auto_function_declarator_not_declaration : Error<
   "'decltype(auto)' can only be used as a return type "
   "in a function declaration">;
 def err_decltype_auto_compound_type : Error<
   "cannot form %select{pointer to|reference to|array of}0 'decltype(auto)'">;
 def err_decltype_auto_initializer_list : Error<
   "cannot deduce 'decltype(auto)' from initializer list">;
 
 // C++17 deduced class template specialization types
 def err_deduced_class_template_compound_type : Error<
   "cannot %select{form pointer to|form reference to|form array of|"
   "form function returning|use parentheses when declaring variable with}0 "
   "deduced class template specialization type">;
 def err_deduced_non_class_template_specialization_type : Error<
   "%select{<error>|function template|variable template|alias template|"
   "template template parameter|concept|template}0 %1 requires template "
   "arguments; argument deduction only allowed for class templates">;

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
   // Nothing to print: we picked up the default argument.
 }
 
 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
   // Nothing to print: we picked up the default initializer.
 }
 
 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
-  Node->getType().print(OS, Policy);
-  // If there are no parens, this is list-initialization, and the braces are
-  // part of the syntax of the inner construct.
-  if (Node->getLParenLoc().isValid())
-    OS << "(";
+  auto TargetType = Node->getType();
+  auto *Auto = TargetType->getContainedDeducedType();
+  bool Bare = Auto && Auto->isDeduced();
+
+  // Parenthesize deduced casts.
+  if (Bare)
+    OS << '(';
+  TargetType.print(OS, Policy);
+  if (Bare)
+    OS << ')';
+
+  // No extra braces surrounding the inner construct.
+  if (!Node->isListInitialization())
+    OS << '(';
   PrintExpr(Node->getSubExpr());
-  if (Node->getLParenLoc().isValid())
-    OS << ")";
+  if (!Node->isListInitialization())
+    OS << ')';
 }
 
 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
   PrintExpr(Node->getSubExpr());
 }
 
 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
   Node->getType().print(OS, Policy);

clang/lib/Parse/ParseDeclCXX.cpp

if (Tok.is(tok::annot_decltype)) {
     if (T.expectAndConsume(diag::err_expected_lparen_after,
                            "decltype", tok::r_paren)) {
       DS.SetTypeSpecError();
       return T.getOpenLocation() == Tok.getLocation() ?
              StartLoc : T.getOpenLocation();
     }
 
     // Check for C++1y 'decltype(auto)'.
-    if (Tok.is(tok::kw_auto)) {
-      // No need to disambiguate here: an expression can't start with 'auto',
-      // because the typename-specifier in a function-style cast operation can't
-      // be 'auto'.
+    if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) {
+      // the typename-specifier in a function-style cast expression may
+      // be 'auto' since C++2b.
       Diag(Tok.getLocation(),
            getLangOpts().CPlusPlus14
              ? diag::warn_cxx11_compat_decltype_auto_type_specifier
              : diag::ext_decltype_auto_type_specifier);
       ConsumeToken();
     } else {
       // Parse the expression
 

clang/lib/Parse/ParseExpr.cpp

#undef RTT_JOIN
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw___ibm128:
   case tok::kw_void:
+  case tok::kw_auto:
   case tok::kw_typename:
   case tok::kw_typeof:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
   {
     if (!getLangOpts().CPlusPlus) {
       Diag(Tok, diag::err_expected_expression);

clang/lib/Parse/ParseExprCXX.cpp

case tok::kw_signed:
     DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
     break;
   case tok::kw_unsigned:
     DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID);
     break;
   case tok::kw_void:
     DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
     break;
+  case tok::kw_auto:
+    DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID, Policy);
+    break;
   case tok::kw_char:
     DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_int:
     DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw___int128:
     DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);

clang/lib/Sema/SemaExprCXX.cpp

InitializationKind Kind =
                 : InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc,
                                                    RParenOrBraceLoc)
           : InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc,
                                             RParenOrBraceLoc);
 
   // C++1z [expr.type.conv]p1:
   //   If the type is a placeholder for a deduced class type, [...perform class
   //   template argument deduction...]
+  // C++2b:
+  //   Otherwise, if the type contains a placeholder type, it is replaced by the
+  //   type determined by placeholder type deduction.
   DeducedType *Deduced = Ty->getContainedDeducedType();
   if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
     Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity,
                                                      Kind, Exprs);
     if (Ty.isNull())
       return ExprError();
     Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
+  } else if (Deduced) {
+    MultiExprArg Inits = Exprs;
+    if (ListInitialization) {
+      auto *ILE = cast<InitListExpr>(Exprs[0]);
+      Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits());
+    }
+
+    if (Inits.empty())
+      return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
+                       << Ty << FullRange);
+    if (Inits.size() > 1) {
+      Expr *FirstBad = Inits[1];
+      return ExprError(Diag(FirstBad->getBeginLoc(),
+                            diag::err_auto_expr_init_multiple_expressions)
+                       << Ty << FullRange);
+    }
+    if (getLangOpts().CPlusPlus2b) {
+      if (Ty->getAs<AutoType>())
+        Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
+    }
+    Expr *Deduce = Inits[0];
+    if (isa<InitListExpr>(Deduce))
+      return ExprError(
+          Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
+          << ListInitialization << Ty << FullRange);
+    QualType DeducedType;
+    if (DeduceAutoType(TInfo, Deduce, DeducedType) == DAR_Failed)
+      return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
+                       << Ty << Deduce->getType() << FullRange
+                       << Deduce->getSourceRange());
+    if (DeducedType.isNull())
+      return ExprError();
+
+    Ty = DeducedType;
+    Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
   }
 
   if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
     // FIXME: CXXUnresolvedConstructExpr does not model list-initialization
     // directly. We work around this by dropping the locations of the braces.
     SourceRange Locs = ListInitialization
                            ? SourceRange()
                            : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
if (DirectInitRange.isValid()) {
     initStyle = CXXNewExpr::ListInit;
   else {
     assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
             isa<CXXConstructExpr>(Initializer)) &&
            "Initializer expression that cannot have been implicitly created.");
     initStyle = CXXNewExpr::NoInit;
   }
 
-  Expr **Inits = &Initializer;
-  unsigned NumInits = Initializer ? 1 : 0;
+  MultiExprArg Exprs(&Initializer, Initializer ? 1 : 0);
   if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
     assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
-    Inits = List->getExprs();
-    NumInits = List->getNumExprs();
+    Exprs = MultiExprArg(List->getExprs(), List->getNumExprs());
   }
 
   // C++11 [expr.new]p15:
   //   A new-expression that creates an object of type T initializes that
   //   object as follows:
   InitializationKind Kind
       //     - If the new-initializer is omitted, the object is default-
       //       initialized (8.5); if no initialization is performed,
if (ArraySize)
           Diag(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.getBegin(),
                diag::err_deduced_class_template_compound_type)
           << /*array*/ 2
           << (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
 
     InitializedEntity Entity
       = InitializedEntity::InitializeNew(StartLoc, AllocType);
     AllocType = DeduceTemplateSpecializationFromInitializer(
-        AllocTypeInfo, Entity, Kind, MultiExprArg(Inits, NumInits));
+        AllocTypeInfo, Entity, Kind, Exprs);
     if (AllocType.isNull())
       return ExprError();
   } else if (Deduced) {
+    MultiExprArg Inits = Exprs;
     bool Braced = (initStyle == CXXNewExpr::ListInit);
-    if (NumInits == 1) {
-      if (auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) {
-        Inits = p->getInits();
-        NumInits = p->getNumInits();
-        Braced = true;
-      }
+    if (Braced) {
+      auto *ILE = cast<InitListExpr>(Exprs[0]);
+      Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits());
     }
 
-    if (initStyle == CXXNewExpr::NoInit || NumInits == 0)
+    if (initStyle == CXXNewExpr::NoInit || Inits.empty())
       return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
                        << AllocType << TypeRange);
-    if (NumInits > 1) {
+    if (Inits.size() > 1) {
       Expr *FirstBad = Inits[1];
       return ExprError(Diag(FirstBad->getBeginLoc(),
                             diag::err_auto_new_ctor_multiple_expressions)
                        << AllocType << TypeRange);
     }
     if (Braced && !getLangOpts().CPlusPlus17)
       Diag(Initializer->getBeginLoc(), diag::ext_auto_new_list_init)
           << AllocType << TypeRange;
     Expr *Deduce = Inits[0];
+    if (isa<InitListExpr>(Deduce))
+      return ExprError(
+          Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
+          << Braced << AllocType << TypeRange);
     QualType DeducedType;
     if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
       return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
                        << AllocType << Deduce->getType()
                        << TypeRange << Deduce->getSourceRange());
     if (DeducedType.isNull())
       return ExprError();
     AllocType = DeducedType;
if (PlacementArgs.empty() && !PassAlignment &&
             << unsigned(NewAlignment / Context.getCharWidth());
     }
   }
 
   // Array 'new' can't have any initializers except empty parentheses.
   // Initializer lists are also allowed, in C++11. Rely on the parser for the
   // dialect distinction.
   if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) {
-    SourceRange InitRange(Inits[0]->getBeginLoc(),
-                          Inits[NumInits - 1]->getEndLoc());
+    SourceRange InitRange(Exprs.front()->getBeginLoc(),
+                          Exprs.back()->getEndLoc());
     Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
     return ExprError();
   }
 
   // If we can perform the initialization, and we've not already done so,
   // do it now.
   if (!AllocType->isDependentType() &&
-      !Expr::hasAnyTypeDependentArguments(
-          llvm::makeArrayRef(Inits, NumInits))) {
+      !Expr::hasAnyTypeDependentArguments(Exprs)) {
     // The type we initialize is the complete type, including the array bound.
     QualType InitType;
     if (KnownArraySize)
       InitType = Context.getConstantArrayType(
           AllocType,
           llvm::APInt(Context.getTypeSize(Context.getSizeType()),
                       *KnownArraySize),
           *ArraySize, ArrayType::Normal, 0);
     else if (ArraySize)
       InitType =
           Context.getIncompleteArrayType(AllocType, ArrayType::Normal, 0);
     else
       InitType = AllocType;
 
     InitializedEntity Entity
       = InitializedEntity::InitializeNew(StartLoc, InitType);
-    InitializationSequence InitSeq(*this, Entity, Kind,
-                                   MultiExprArg(Inits, NumInits));
-    ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
-                                          MultiExprArg(Inits, NumInits));
+    InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
+    ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind, Exprs);
     if (FullInit.isInvalid())
       return ExprError();
 
     // FullInit is our initializer; strip off CXXBindTemporaryExprs, because
     // we don't want the initialized object to be destructed.
     // FIXME: We should not create these in the first place.
     if (CXXBindTemporaryExpr *Binder =
             dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get()))

clang/lib/Sema/SemaType.cpp

if (Deduced) {
     case DeclaratorContext::ConversionId:
       if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
         Error = 14; // conversion-type-id
       IsDeducedReturnType = true;
       break;
     case DeclaratorContext::FunctionalCast:
       if (isa<DeducedTemplateSpecializationType>(Deduced))
         break;
+      if (SemaRef.getLangOpts().CPlusPlus2b && IsCXXAutoType &&
+          !Auto->isDecltypeAuto())
+        break; // auto(x)
       LLVM_FALLTHROUGH;
     case DeclaratorContext::TypeName:
       Error = 15; // Generic
       break;
     case DeclaratorContext::File:
     case DeclaratorContext::Block:
     case DeclaratorContext::ForInit:
     case DeclaratorContext::SelectionInit:

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp

 void j() {
   (void)typeid(auto); // expected-error{{'auto' not allowed here}}
   (void)sizeof(auto); // expected-error{{'auto' not allowed here}}
   (void)__alignof(auto); // expected-error{{'auto' not allowed here}}
 
   U<auto> v; // expected-error{{'auto' not allowed in template argument}}
 
   int n;
-  (void)dynamic_cast<auto&>(n); // expected-error{{'auto' not allowed here}}
-  (void)static_cast<auto*>(&n); // expected-error{{'auto' not allowed here}}
-  (void)reinterpret_cast<auto*>(&n); // expected-error{{'auto' not allowed here}}
-  (void)const_cast<auto>(n); // expected-error{{'auto' not allowed here}}
-  (void)*(auto*)(&n); // expected-error{{'auto' not allowed here}}
-  (void)auto(n); // expected-error{{expected expression}}
-  (void)auto{n}; // expected-error{{expected expression}}
+  (void)dynamic_cast<auto &>(n);      // expected-error{{'auto' not allowed here}}
+  (void)static_cast<auto *>(&n);      // expected-error{{'auto' not allowed here}}
+  (void)reinterpret_cast<auto *>(&n); // expected-error{{'auto' not allowed here}}
+  (void)const_cast<auto const>(n);    // expected-error{{'auto' not allowed here}}
+  (void)*(auto *)(&n);                // expected-error{{'auto' not allowed here}}
+  (void)dynamic_cast<auto>(n);        // expected-error{{'auto' not allowed here}}
+  (void)static_cast<auto>(n);         // expected-error{{'auto' not allowed here}}
+  (void)reinterpret_cast<auto>(n);    // expected-error{{'auto' not allowed here}}
+  (void)const_cast<auto>(n);          // expected-error{{'auto' not allowed here}}
+  (void)(auto)(n);                    // expected-error{{'auto' not allowed here}}
+  (void)auto(n);                      // expected-error{{'auto' not allowed here}}
+  (void)auto{n};                      // expected-error{{'auto' not allowed here}}
 }
 
 template <auto a = 10> class C { }; // expected-error{{'auto' not allowed in template parameter}}
 int ints[] = {1, 2, 3};
 template <const auto (*a)[3] = &ints> class D { }; // expected-error{{'auto' not allowed in template parameter}}
 enum E : auto {}; // expected-error{{'auto' not allowed here}}
 struct F : auto {}; // expected-error{{expected class name}}
 template<typename T = auto> struct G { }; // expected-error{{'auto' not allowed in template argument}}
 
 using A = auto; // expected-error{{'auto' not allowed in type alias}}
 
 auto k() -> auto; // expected-error{{'auto' not allowed in function return type}}

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

+// RUN: %clang_cc1 -std=c++2b -verify %s
+
+// p2.3 allows only T = auto in T(x).
+
+void test_decay() {
+  int v[3];
+  static_assert(__is_same(decltype(auto(v)), int *));
+  static_assert(__is_same(decltype(auto{v}), int *));
+  static_assert(__is_same(decltype(auto("lit")), char const *));
+  static_assert(__is_same(decltype(auto{"lit"}), char const *));
+
+  constexpr long i = 1;
+  static_assert(__is_same(decltype(i), long const));
+  static_assert(__is_same(decltype(auto(1L)), long));
+  static_assert(__is_same(decltype(auto{1L}), long));
+  static_assert(__is_same(decltype(auto(i)), long));
+  static_assert(__is_same(decltype(auto{i}), long));
+
+  class A {
+  } a;
+  A const ac;
+
+  static_assert(__is_same(decltype(auto(a)), A));
+  static_assert(__is_same(decltype(auto(ac)), A));
+
+  A &lr = a;
+  A const &lrc = a;
+  A &&rr = static_cast<A &&>(a);
+  A const &&rrc = static_cast<A &&>(a);
+
+  static_assert(__is_same(decltype(auto(lr)), A));
+  static_assert(__is_same(decltype(auto(lrc)), A));
+  static_assert(__is_same(decltype(auto(rr)), A));
+  static_assert(__is_same(decltype(auto(rrc)), A));
+}
+
+class cmdline_parser {
+public:
+  cmdline_parser(char const *);
+  auto add_option(char const *, char const *) && -> cmdline_parser &&;
+};
+
+void test_rvalue_fluent_interface() {
+  auto cmdline = cmdline_parser("driver");
+  auto internal = auto{cmdline}.add_option("--dump-full", "do not minimize dump");
+}
+
+template <class T> constexpr auto decay_copy(T &&v) { return static_cast<T &&>(v); } // expected-error {{calling a protected constructor}}
+
+class A {
+  int x;
+  friend void f(A &&);
+
+public:
+  A();
+
+  auto test_access() {
+    static_assert(__is_same(decltype(auto(*this)), A));
+    static_assert(__is_same(decltype(auto(this)), A *));
+
+    f(A(*this));          // ok
+    f(auto(*this));       // ok in P0849
+    f(decay_copy(*this)); // expected-note {{in instantiation of function template specialization}}
+  }
+
+  auto test_access() const {
+    static_assert(__is_same(decltype(auto(*this)), A)); // ditto
+    static_assert(__is_same(decltype(auto(this)), A const *));
+  }
+
+protected:
+  A(const A &); // expected-note {{declared protected here}}
+};
+
+// post-C++17 semantics
+namespace auto_x {
+constexpr struct Uncopyable {
+  constexpr explicit Uncopyable(int) {}
+  constexpr Uncopyable(Uncopyable &&) = delete;
+} u = auto(Uncopyable(auto(Uncopyable(42))));
+} // namespace auto_x

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

+// RUN: %clang_cc1 -std=c++2b -verify %s
+
+template <class T>
+void foo(T);
+
+struct A {
+  int m;
+  char g(int);
+  float g(double);
+} a{1};
+
+// C++2b [dcl.type.auto.deduct]p2.3
+// For an explicit type conversion, T is the specified type, which shall be auto.
+void diagnostics() {
+  foo(auto());   // expected-error {{initializer for functional-style cast to 'auto' is empty}}
+  foo(auto{});   // expected-error {{initializer for functional-style cast to 'auto' is empty}}
+  foo(auto({})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  foo(auto{{}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
+
+  // - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression.
+  foo(auto(a));
+  // - If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
+  foo(auto{a});
+  foo(auto({a})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  foo(auto{{a}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
+
+  foo(auto(&A::g)); // expected-error {{functional-style cast to 'auto' has incompatible initializer of type '<overloaded function type>'}}
+
+  foo(auto(a, 3.14));     // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
+  foo(auto{a, 3.14});     // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
+  foo(auto({a, 3.14}));   // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  foo(auto{{a, 3.14}});   // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
+  foo(auto({a}, {3.14})); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
+  foo(auto{{a}, {3.14}}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
+
+  foo(auto{1, 2});   // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
+  foo(auto({1, 2})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  foo(auto{{1, 2}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
+}

clang/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp

void f() {
   only<double*> q = new (auto) (0.0);
   only<char*> r = new auto {'a'};
 
   new auto; // expected-error{{new expression for type 'auto' requires a constructor argument}}
   new (const auto)(); // expected-error{{new expression for type 'const auto' requires a constructor argument}}
   new (auto) (1,2,3); // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
   new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}}
   new auto {1,2,3}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
-  new auto ({1,2,3}); // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
+  new auto ({1,2,3}); // expected-error{{cannot deduce actual type for 'auto' from parenthesized initializer list}}
 }
 
 void p2example() {
   only<int*> r = new auto(1);
   auto x = new auto('a');
 
   only<char*> testX = x;
 }

clang/test/CXX/expr/expr.unary/expr.new/p2-cxx14.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 -pedantic
 
 void f() {
   new auto('a');
   new auto {2}; // expected-warning {{ISO C++ standards before C++17 do not allow new expression for type 'auto' to use list-initialization}}
   new auto {1, 2}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
   new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}}
-  new decltype(auto)({1}); // expected-warning {{ISO C++ standards before C++17 do not allow new expression for type 'decltype(auto)' to use list-initialization}}
-  new decltype(auto)({1, 2}); // expected-error{{new expression for type 'decltype(auto)' contains multiple constructor arguments}}
+  new decltype(auto)({1}); // expected-error{{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  new decltype(auto)({1, 2}); // expected-error{{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
 }

clang/test/CXX/expr/expr.unary/expr.new/p2-cxx1z.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -pedantic
 
+// [expr.new]p2 ... the invented declaration: T x init ;
+// C++2b [dcl.type.auto.deduct]p2.2
+// For a variable declared with a type that contains a placeholder type, T is the declared type of the variable.
 void f() {
+  // - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression.
   new auto('a');
-  new auto {2};
-  new auto {1, 2}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
-  new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}}
-  new decltype(auto)({1});
-  new decltype(auto)({1, 2}); // expected-error{{new expression for type 'decltype(auto)' contains multiple constructor arguments}}
+  new decltype(auto)('a');
+  // - If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
+  new auto{2};
+  new decltype(auto){2};
+
+  new auto{};   // expected-error{{new expression for type 'auto' requires a constructor argument}}
+  new auto({}); // expected-error{{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  new auto{{}}; // expected-error{{cannot deduce actual type for 'auto' from nested initializer list}}
+
+  new auto({2});  // expected-error{{cannot deduce actual type for 'auto' from parenthesized initializer list}}
+  new auto{{2}};  // expected-error{{cannot deduce actual type for 'auto' from nested initializer list}}
+  new auto{1, 2}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
+
+  new decltype(auto){};   // expected-error{{new expression for type 'decltype(auto)' requires a constructor argument}}
+  new decltype(auto)({}); // expected-error{{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  new decltype(auto){{}}; // expected-error{{cannot deduce actual type for 'decltype(auto)' from nested initializer list}}
+
+  new decltype(auto)({1});    // expected-error{{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  new decltype(auto){1, 2};   // expected-error{{new expression for type 'decltype(auto)' contains multiple constructor arguments}}
+  new decltype(auto)({1, 2}); // expected-error{{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
 }

clang/test/Parser/cxx2b-auto-x.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx2b -std=c++2b -Wpre-c++2b-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s
+
+void looks_like_decltype_auto() {
+  decltype(auto(42)) b = 42; // cxx20-error {{'auto' not allowed here}} \
+                                cxx2b-warning {{'auto' as a functional-style cast is incompatible with C++ standards before C++2b}}
+  decltype(long *) a = 42;   // expected-error {{expected '(' for function-style cast or type construction}} \
+                                expected-error {{expected expression}}
+  decltype(auto *) a = 42;   // expected-error {{expected '(' for function-style cast or type construction}} \
+                                expected-error {{expected expression}}
+  decltype(auto()) c = 42;   // cxx2b-error {{initializer for functional-style cast to 'auto' is empty}} \
+                                cxx20-error {{'auto' not allowed here}}
+}
+
+struct looks_like_declaration {
+  int n;
+} a;
+
+using T = looks_like_declaration *;
+void f() { T(&a)->n = 1; }
+// FIXME: They should be deemed expressions without breaking function pointer
+//        parameter declarations with trailing return types.
+// void g() { auto(&a)->n = 0; }
+// void h() { auto{&a}->n = 0; }

clang/test/SemaCXX/cxx2b-ast-print.cpp

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -ast-print %s | FileCheck %s
+
+void test_auto_expr(long long y, auto &&z) {
+  int x[] = {3, 4};
+
+  // CHECK{LITERAL}: (int)(x[1])
+  void(auto(x[1]));
+  // CHECK{LITERAL}: (int){x[1]}
+  void(auto{x[1]});
+
+  // CHECK{LITERAL}: (int *)(x)
+  void(auto(x));
+  // CHECK{LITERAL}: (int *){x}
+  void(auto{x});
+
+  // CHECK{LITERAL}: auto(z)
+  void(auto(z));
+  // CHECK{LITERAL}: auto({z})
+  void(auto{z}); // T({z}) is legal unless T = auto
+
+  // CHECK{LITERAL}: new int *(x)
+  void(new auto(x));
+  // CHECK{LITERAL}: new int *{x}
+  void(new auto{x});
+
+  // CHECK{LITERAL}: new long long(y)
+  void(new decltype(auto)(y));
+  // CHECK{LITERAL}: new long long{y}
+  void(new decltype(auto){y});
+}

clang/www/cxx_status.html

<tr>
       <td><a href="https://wg21.link/P2334R1">P2334R1</a></td>
       <td class="full" align="center">Clang 13</td>
     </tr>
     <tr>
       <td>Extend init-statement to allow alias-declaration</td>
       <td><a href="https://wg21.link/P2360R0">P2360R0</a></td>
       <td class="unreleased" align="center">Clang 14</td>
     </tr>
+    <tr>
+      <td>auto(x): decay-copy in the language</td>
+      <td><a href="https://wg21.link/P0849R8">P0849R8</a></td>
+      <td class="unreleased" align="center">Clang 15</td>
+    </tr>
     <!-- February 2022 papers -->
     <tr>
       <td>Attributes on Lambda-Expressions</td>
       <td><a href="https://wg21.link/P2173R1">P2173R1</a></td>
       <td class="full" align="center">Clang 13</td>
     </tr>
     <tr>
       <td><tt>constexpr</tt> for <tt><cmath</tt> and <tt>cstdlib</tt></td>