[Clang] Fix parsing of `(auto(x))`.

[cor3ntin]

Summary

Allow auto(x) to appear in a parenthesis
expression.

The pattern (auto( can appear as part of a declarator,
so the parser is modified to avoid the ambiguity,
in a way consistent with the proposed resolution to CWG1223.

[cor3ntin]

Fix whitespace only changes

[aaron.ballman]

clang/docs/ReleaseNotes.rst

459

clang/include/clang/Parse/Parser.h

2657

2665–2666

clang/lib/Parse/ParseTentative.cpp

234

This smells a bit off to me because of the comments above -- this is trying to parse an elaborated type specifier, and auto cannot appear in this position for that case. Can you help me understand what's going on?

320

542

1413–1414

This seems incorrect to me, consider:

auto [[clang::annotate_type("test")]] i = 12;

https://godbolt.org/z/7Gx3Gb18h

1415–1417

2114

clang/test/Parser/cxx1z-decomposition.cpp

99–101

This first diagnostic is incorrect -- auto is definitely allowed there, just that the rest of the declaration is nonsense. I think the "use of undeclared identifier" diagnostic is reasonable. The lambda diagnostic is.... interesting.

Any way you can improve this, or is that a slog?

[cor3ntin]

• Fix tests
• Address aaron's comments

[cor3ntin]

Do not parse auto( as an expression before C++23

[tbaeder]

clang/lib/Parse/ParseTentative.cpp

1064

Not part of this commit I guess, but four bool parameters is truly horrific :/

[cor3ntin]

clang/lib/Parse/ParseTentative.cpp

234

You are right, this should not have been committed, nice catch!

clang/test/Parser/cxx1z-decomposition.cpp

99–101

There were multiple issues there.

The "decomposition declaration cannot be declared with parenthese" error which i had remove can still occur at global scope where a declaration is expected so i put that back and added a test.
Then, I'm running all the tests in c++17 and 23 modes as the behavior is different.

I did restore the current behavior in C++20 and earlier modes, such that we will always consider auto starts a declaration. That way we can have that structured binding in parentheses diag.

But in c++23 mode, We establish it's not a valid declarator. so we parse it as an expression. [ is always considered as a lambda introducer, which it could be, ie auto([c] {}); is a valid expression assuming that C exists.
At that point trying to figure out that ] is not followed by { and is therefore not a lambda seems extremely tricky as you can have arbitrary long expressions between the square brackets.

[aaron.ballman]

clang/lib/Parse/ParseTentative.cpp

1064

Yeah, a refactoring here would not be amiss (but outside of this patch, I think).

1413–1414

Ignore this -- l_brace is not l_square. :-D

clang/test/Parser/cxx1z-decomposition.cpp

99–101

Thanks for the explanation -- that seems defensible to me.

[cor3ntin]

Fix tests

[aaron.ballman]

The changes generally LGTM, but:

in a way consistent with the proposed resolution to CWG1223.

What are the chances that CWG changes their mind and picks a different direction?

[cor3ntin]

In D149276#4302700, @aaron.ballman wrote:

The changes generally LGTM, but:

in a way consistent with the proposed resolution to CWG1223.

What are the chances that CWG changes their mind and picks a different direction?

CWG acts in mysterious ways, so it's hard to tell. but i think anything else than this resolution could potentially break code?

clang/lib/Parse/ParseTentative.cpp

1064

Agreed, we probably want an enum there instead, i could follow up

[cor3ntin]

@rsmith @hubert.reinterpretcast do you see any reason not to go ahead with this?

[shafik]

I see that we do have an issue but so far the examples in the tests don't feel very natural and so I would like to understand if there is a larger motivation here.

[cor3ntin]

In D149276#4305780, @shafik wrote:

I see that we do have an issue but so far the examples in the tests don't feel very natural and so I would like to understand if there is a larger motivation here.

The context is that a user realized we fail to implement P0849 https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0849r8.html
and as a result we fail to compile simple range code https://godbolt.org/z/3ajj1c135 (this was observed by a user on the llvm discord and i don't think they made a github issue, unfortunately)

[cor3ntin]

@aaron.ballman this won;t get approve by core un

In D149276#4302700, @aaron.ballman wrote:

The changes generally LGTM, but:

in a way consistent with the proposed resolution to CWG1223.

What are the chances that CWG changes their mind and picks a different direction?

They were happy with the direction friday when we looked at it ( not the wording though). I think we should go ahead, waiting until after issaquah might be a bit too late (and if we are claiming auto(x) is implemented we should merge that in 17)

[aaron.ballman]

In D149276#4341552, @cor3ntin wrote:

@aaron.ballman this won;t get approve by core un

In D149276#4302700, @aaron.ballman wrote:

The changes generally LGTM, but:

in a way consistent with the proposed resolution to CWG1223.

What are the chances that CWG changes their mind and picks a different direction?

They were happy with the direction friday when we looked at it ( not the wording though). I think we should go ahead, waiting until after issaquah might be a bit too late (and if we are claiming auto(x) is implemented we should merge that in 17)

We don't have to wait for the wording to be final so long as the direction is in line with what you've done here, so LGTM! Thank you!

[cor3ntin]

Rebase

[kadircet]

hi!

this seem to have regressed compilation for some valid C++ code:

struct Bar {
  const char *name();
};
struct Baz {
  static Bar *method();
};
struct Foo {
  Foo(const char *);
};

template <typename T> void bar() { Foo _(T::method()->name()); }
void foo() { bar<Baz>(); }

compiles fine without this change, starting with this it produces the following error:

a.cc:11:55: error: expected unqualified-id
template <typename T> void bar() { Foo _(T::method()->name()); }
                                                      ^
a.cc:11:40: error: no matching constructor for initialization of 'Foo'
template <typename T> void bar() { Foo _(T::method()->name()); }
                                       ^
a.cc:12:14: note: in instantiation of function template specialization 'bar<Baz>' requested here
void foo() { bar<Baz>(); }
             ^
a.cc:8:3: note: candidate constructor not viable: requires 1 argument, but 0 were provided
  Foo(const char *);
  ^
a.cc:7:8: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
struct Foo {
       ^
a.cc:7:8: note: candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided

https://github.com/llvm/llvm-project/issues/62733 is the bug report that triggered the investigation.

[cor3ntin]

@kadircet thanks for letting me know, I'm investigating

[cor3ntin]

• When tentative parse an abstract declarator whithout auto specifier, do not classify it as a declaration based on the presence of arrow
• When tentative parse a declarion vs member access, do not annotate the token after the arrow expression as this annotation would be incorrect.

[aaron.ballman]

clang/lib/Parse/ParseTentative.cpp

2178–2182

This comment looks like it can be re-flowed to 80 columns instead of shortened like this.

2185–2187

Something smells off here -- NextToken() is a peek; were you trying to advance the tokens stream? If not, then Next.is(...) would be more clear.

[cor3ntin]

Address Aaron's feedback

[aaron.ballman]

LGTM!

clang/docs/ReleaseNotes.rst

- Stop stripping CV qualifiers from the type of ``this`` when capturing it by value in
   (`#50866 <https://github.com/llvm/llvm-project/issues/50866>`_)
 - Fix ordering of function templates by constraints when they have template
   template parameters with different nested constraints.
 - Fix type equivalence comparison between auto types to take constraints into
   account.
 - Fix bug in the computation of the ``__has_unique_object_representations``
   builtin for types with unnamed bitfields.
   (`#61336 <https://github.com/llvm/llvm-project/issues/61336>`_)
 - Fix default member initializers sometimes being ignored when performing
   parenthesized aggregate initialization of templated types.
   (`#62266 <https://github.com/llvm/llvm-project/issues/62266>`_)
 - Fix overly aggressive lifetime checks for parenthesized aggregate
   initialization.
   (`#61567 <https://github.com/llvm/llvm-project/issues/61567>`_)
 - Fix a crash when expanding a pack as the index of a subscript expression.
 - Fix handling of constexpr dynamic memory allocations in template
   arguments. (`#62462 <https://github.com/llvm/llvm-project/issues/62462>`_)
 - Some predefined expressions are now treated as string literals in MSVC
   compatibility mode.
   (`#114 <https://github.com/llvm/llvm-project/issues/114>`_)
+- Fix parsing of `auto(x)`, when it is surrounded by parentheses.
+  (`#62494 <https://github.com/llvm/llvm-project/issues/62494>`_)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Preserve ``namespace`` definitions that follow malformed declarations.
 
 Miscellaneous Bug Fixes
 ^^^^^^^^^^^^^^^^^^^^^^^

clang/include/clang/Parse/Parser.h

bool isConstructorDeclarator(
       DeclSpec::FriendSpecified IsFriend = DeclSpec::FriendSpecified::No,
       const ParsedTemplateInfo *TemplateInfo = nullptr);
 
   /// Specifies the context in which type-id/expression
   /// disambiguation will occur.
   enum TentativeCXXTypeIdContext {
     TypeIdInParens,
     TypeIdUnambiguous,
-    TypeIdAsTemplateArgument
+    TypeIdAsTemplateArgument,
+    TypeIdInTrailingReturnType,
   };
 
-
   /// isTypeIdInParens - Assumes that a '(' was parsed and now we want to know
   /// whether the parens contain an expression or a type-id.
   /// Returns true for a type-id and false for an expression.
   bool isTypeIdInParens(bool &isAmbiguous) {
     if (getLangOpts().CPlusPlus)
       return isCXXTypeId(TypeIdInParens, isAmbiguous);
     isAmbiguous = false;
     return isTypeSpecifierQualifier();
private:
   // that more tentative parsing is necessary for disambiguation.
   // They all consume tokens, so backtracking should be used after calling them.
 
   TPResult TryParseSimpleDeclaration(bool AllowForRangeDecl);
   TPResult TryParseTypeofSpecifier();
   TPResult TryParseProtocolQualifiers();
   TPResult TryParsePtrOperatorSeq();
   TPResult TryParseOperatorId();
-  TPResult TryParseInitDeclaratorList();
+  TPResult TryParseInitDeclaratorList(bool MayHaveTrailingReturnType = false);
   TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
-                              bool mayHaveDirectInit = false);
+                              bool mayHaveDirectInit = false,
+                              bool mayHaveTrailingReturnType = false);
   TPResult TryParseParameterDeclarationClause(
       bool *InvalidAsDeclaration = nullptr, bool VersusTemplateArg = false,
       ImplicitTypenameContext AllowImplicitTypename =
           ImplicitTypenameContext::No);
-  TPResult TryParseFunctionDeclarator();
+  TPResult TryParseFunctionDeclarator(bool MayHaveTrailingReturnType = false);
+  bool NameAfterArrowIsNonType();
   TPResult TryParseBracketDeclarator();
   TPResult TryConsumeDeclarationSpecifier();
 
   /// Try to skip a possibly empty sequence of 'attribute-specifier's without
   /// full validation of the syntactic structure of attributes.
   bool TrySkipAttributes();
 
   /// Diagnoses use of _ExtInt as being deprecated, and diagnoses use of

clang/lib/Parse/ParseDecl.cpp

void Parser::ParseDirectDeclarator(Declarator &D) {
   }
 
   if (Tok.is(tok::l_paren)) {
     // If this might be an abstract-declarator followed by a direct-initializer,
     // check whether this is a valid declarator chunk. If it can't be, assume
     // that it's an initializer instead.
     if (D.mayOmitIdentifier() && D.mayBeFollowedByCXXDirectInit()) {
       RevertingTentativeParsingAction PA(*this);
-      if (TryParseDeclarator(true, D.mayHaveIdentifier(), true) ==
-              TPResult::False) {
+      if (TryParseDeclarator(true, D.mayHaveIdentifier(), true,
+                             D.getDeclSpec().getTypeSpecType() == TST_auto) ==
         D.SetIdentifier(nullptr, Tok.getLocation());
         goto PastIdentifier;
       }
     }
 
     // direct-declarator: '(' declarator ')'
     // direct-declarator: '(' attributes declarator ')'
     // Example: 'char (*X)'   or 'int (*XX)(void)'

clang/lib/Parse/ParseTentative.cpp

case tok::kw_enum:
     // Skip attributes.
     if (!TrySkipAttributes())
       return TPResult::Error;
 
     if (TryAnnotateOptionalCXXScopeToken())
       return TPResult::Error;
     if (Tok.is(tok::annot_cxxscope))
       ConsumeAnnotationToken();
     if (Tok.is(tok::identifier))
       ConsumeToken();
     else if (Tok.is(tok::annot_template_id))
       ConsumeAnnotationToken();
     else
       return TPResult::Error;
     break;
 
   case tok::annot_cxxscope:

 ///   decl-specifier-seq init-declarator-list[opt] ';'
 ///
 /// (if AllowForRangeDecl specified)
 /// for ( for-range-declaration : for-range-initializer ) statement
 /// for-range-declaration:
 ///    attribute-specifier-seqopt type-specifier-seq declarator
 ///
 Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
+  bool DeclSpecifierIsAuto = Tok.is(tok::kw_auto);
   if (TryConsumeDeclarationSpecifier() == TPResult::Error)
     return TPResult::Error;
 
   // Two decl-specifiers in a row conclusively disambiguate this as being a
   // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
   // overwhelmingly common case that the next token is a '('.
   if (Tok.isNot(tok::l_paren)) {
     TPResult TPR = isCXXDeclarationSpecifier(ImplicitTypenameContext::No);
     if (TPR == TPResult::Ambiguous)
       return TPResult::True;
     if (TPR == TPResult::True || TPR == TPResult::Error)
       return TPR;
     assert(TPR == TPResult::False);
   }
 
-  TPResult TPR = TryParseInitDeclaratorList();
+  TPResult TPR = TryParseInitDeclaratorList(
+      /*mayHaveTrailingReturnType=*/DeclSpecifierIsAuto);
   if (TPR != TPResult::Ambiguous)
     return TPR;
 
   if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
     return TPResult::False;
 
   return TPResult::Ambiguous;
 }

 ///       initializer-clause:
 ///         assignment-expression
 ///         braced-init-list
 ///
 ///       braced-init-list:
 ///         '{' initializer-list ','[opt] '}'
 ///         '{' '}'
 ///
-Parser::TPResult Parser::TryParseInitDeclaratorList() {
+Parser::TPResult
+Parser::TryParseInitDeclaratorList(bool MayHaveTrailingReturnType) {
   while (true) {
     // declarator
-    TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
+    TPResult TPR = TryParseDeclarator(
+        /*mayBeAbstract=*/false,
+        /*mayHaveIdentifier=*/true,
+        /*mayHaveDirectInit=*/false,
+        /*mayHaveTrailingReturnType=*/MayHaveTrailingReturnType);
     if (TPR != TPResult::Ambiguous)
       return TPR;
 
     // [GNU] simple-asm-expr[opt] attributes[opt]
     if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute))
       return TPResult::True;
 
     // initializer[opt]
if (CanBeInitStatement && Tok.is(tok::kw_using))
     return ConditionOrInitStatement::InitStmtDecl;
   if (State.update(isCXXDeclarationSpecifier(ImplicitTypenameContext::No)))
     return State.result();
 
   // It might be a declaration; we need tentative parsing.
   RevertingTentativeParsingAction PA(*this);
 
   // FIXME: A tag definition unambiguously tells us this is an init-statement.
+  bool MayHaveTrailingReturnType = Tok.is(tok::kw_auto);
   if (State.update(TryConsumeDeclarationSpecifier()))
     return State.result();
   assert(Tok.is(tok::l_paren) && "Expected '('");
 
   while (true) {
     // Consume a declarator.
-    if (State.update(TryParseDeclarator(false/*mayBeAbstract*/)))
+    if (State.update(TryParseDeclarator(
+            /*mayBeAbstract=*/false,
+            /*mayHaveIdentifier=*/true,
+            /*mayHaveDirectInit=*/false,
+            /*mayHaveTrailingReturnType=*/MayHaveTrailingReturnType)))
       return State.result();
 
     // Attributes, asm label, or an initializer imply this is not an expression.
     // FIXME: Disambiguate properly after an = instead of assuming that it's a
     // valid declaration.
     if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute) ||
         (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) {
       State.markNotExpression();
bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
 
   // FIXME: Add statistics about the number of ambiguous statements encountered
   // and how they were resolved (number of declarations+number of expressions).
 
   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
   // We need tentative parsing...
 
   RevertingTentativeParsingAction PA(*this);
+  bool MayHaveTrailingReturnType = Tok.is(tok::kw_auto);
 
   // type-specifier-seq
   TryConsumeDeclarationSpecifier();
   assert(Tok.is(tok::l_paren) && "Expected '('");
 
   // declarator
-  TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
+  TPR = TryParseDeclarator(true /*mayBeAbstract*/, false /*mayHaveIdentifier*/,
+                           /*mayHaveDirectInit=*/false,
+                           MayHaveTrailingReturnType);
 
   // In case of an error, let the declaration parsing code handle it.
   if (TPR == TPResult::Error)
     TPR = TPResult::True;
 
   if (TPR == TPResult::Ambiguous) {
     // We are supposed to be inside parens, so if after the abstract declarator
     // we encounter a ')' this is a type-id, otherwise it's an expression.
// is a type-id. Otherwise, it's an expression.
                               tok::greatergreatergreater) ||
                   (Tok.is(tok::ellipsis) &&
                    NextToken().isOneOf(tok::greater, tok::greatergreater,
                                        tok::greatergreatergreater,
                                        tok::comma)))))) {
       TPR = TPResult::True;
       isAmbiguous = true;
 
+    } else if (Context == TypeIdInTrailingReturnType) {
+      TPR = TPResult::True;
+      isAmbiguous = true;
     } else
       TPR = TPResult::False;
   }
 
   assert(TPR == TPResult::True || TPR == TPResult::False);
   return TPR == TPResult::True;
 }
 

 ///           conversion-function-id
 ///           literal-operator-id
 ///           '~' class-name                                              [TODO]
 ///           '~' decltype-specifier                                      [TODO]
 ///           template-id                                                 [TODO]
 ///
 Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
                                             bool mayHaveIdentifier,
-                                            bool mayHaveDirectInit) {
+                                            bool mayHaveDirectInit,
+                                            bool mayHaveTrailingReturnType) {
   // declarator:
   //   direct-declarator
   //   ptr-operator declarator
   if (TryParsePtrOperatorSeq() == TPResult::Error)
     return TPResult::Error;
 
   // direct-declarator:
   // direct-abstract-declarator:
if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
     if (mayBeAbstract &&
         (Tok.is(tok::r_paren) || // 'int()' is a function.
                                  // 'int(...)' is a function.
          (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
          isDeclarationSpecifier(
              ImplicitTypenameContext::No))) { // 'int(int)' is a function.
       // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
       //        exception-specification[opt]
-      TPResult TPR = TryParseFunctionDeclarator();
+      TPResult TPR = TryParseFunctionDeclarator(mayHaveTrailingReturnType);
       if (TPR != TPResult::Ambiguous)
         return TPR;
     } else {
       // '(' declarator ')'
       // '(' attributes declarator ')'
       // '(' abstract-declarator ')'
       if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
                       tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
if (Tok.is(tok::l_paren)) {
       // initializers are not possible in contexts where abstract declarators
       // are allowed.
       if (!mayBeAbstract && !isCXXFunctionDeclarator())
         break;
 
       // direct-declarator '(' parameter-declaration-clause ')'
       //        cv-qualifier-seq[opt] exception-specification[opt]
       ConsumeParen();
-      TPR = TryParseFunctionDeclarator();
+      TPR = TryParseFunctionDeclarator(mayHaveTrailingReturnType);
     } else if (Tok.is(tok::l_square)) {
       // direct-declarator '[' constant-expression[opt] ']'
       // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
       TPR = TryParseBracketDeclarator();
     } else if (Tok.is(tok::kw_requires)) {
       // declarator requires-clause
       // A requires clause indicates a function declaration.
       TPR = TPResult::True;
Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
   case tok::kw_typename:  // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
     if (TryAnnotateTypeOrScopeToken(ImplicitTypenameContext::Yes))
       return TPResult::Error;
     return isCXXDeclarationSpecifier(ImplicitTypenameContext::Yes,
                                      BracedCastResult, InvalidAsDeclSpec);
 
+  case tok::kw_auto: {
+    if (!getLangOpts().CPlusPlus23)
+      return TPResult::True;
+    if (NextToken().is(tok::l_brace))
+      return TPResult::False;
+    if (NextToken().is(tok::l_paren))
+      return TPResult::Ambiguous;
+    return TPResult::True;
+  }
+
   case tok::coloncolon: {    // ::foo::bar
     const Token &Next = NextToken();
     if (Next.isOneOf(tok::kw_new,       // ::new
                      tok::kw_delete))   // ::delete
       return TPResult::False;
     [[fallthrough]];
   }
   case tok::kw___super:
Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
   case tok::kw_constexpr:
   case tok::kw_consteval:
   case tok::kw_constinit:
     // storage-class-specifier
   case tok::kw_register:
   case tok::kw_static:
   case tok::kw_extern:
   case tok::kw_mutable:
-  case tok::kw_auto:
   case tok::kw___thread:
   case tok::kw_thread_local:
   case tok::kw__Thread_local:
     // function-specifier
   case tok::kw_inline:
   case tok::kw_virtual:
   case tok::kw_explicit:
 
TPResult TPR = isCXXDeclarationSpecifier(
         AllowImplicitTypename, TPResult::False, InvalidAsDeclaration);
     // A declaration-specifier (not followed by '(' or '{') means this can't be
     // an expression, but it could still be a template argument.
     if (TPR != TPResult::Ambiguous &&
         !(VersusTemplateArgument && TPR == TPResult::True))
       return TPR;
 
     bool SeenType = false;
+    bool DeclarationSpecifierIsAuto = Tok.is(tok::kw_auto);
     do {
       SeenType |= isCXXDeclarationSpecifierAType();
       if (TryConsumeDeclarationSpecifier() == TPResult::Error)
         return TPResult::Error;
 
       // If we see a parameter name, this can't be a template argument.
       if (SeenType && Tok.is(tok::identifier))
         return TPResult::True;
 
       TPR = isCXXDeclarationSpecifier(AllowImplicitTypename, TPResult::False,
                                       InvalidAsDeclaration);
       if (TPR == TPResult::Error)
         return TPR;
 
       // Two declaration-specifiers means this can't be an expression.
       if (TPR == TPResult::True && !VersusTemplateArgument)
         return TPR;
     } while (TPR != TPResult::False);
 
     // declarator
     // abstract-declarator[opt]
-    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
+    TPR = TryParseDeclarator(
+        /*mayBeAbstract=*/true,
+        /*mayHaveIdentifier=*/true,
+        /*mayHaveDirectInit=*/false,
+        /*mayHaveTrailingReturnType=*/DeclarationSpecifierIsAuto);
     if (TPR != TPResult::Ambiguous)
       return TPR;
 
     // [GNU] attributes[opt]
     if (Tok.is(tok::kw___attribute))
       return TPResult::True;
 
     // If we're disambiguating a template argument in a default argument in

 /// Error().
 ///
 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 ///         exception-specification[opt]
 ///
 /// exception-specification:
 ///   'throw' '(' type-id-list[opt] ')'
 ///
-Parser::TPResult Parser::TryParseFunctionDeclarator() {
+Parser::TPResult
+Parser::TryParseFunctionDeclarator(bool MayHaveTrailingReturnType) {
   // The '(' is already parsed.
 
   TPResult TPR = TryParseParameterDeclarationClause();
   if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
     TPR = TPResult::False;
 
   if (TPR == TPResult::False || TPR == TPResult::Error)
     return TPR;
if (Tok.is(tok::kw_noexcept)) {
     if (Tok.is(tok::l_paren)) {
       // Find the matching rparen.
       ConsumeParen();
       if (!SkipUntil(tok::r_paren, StopAtSemi))
         return TPResult::Error;
     }
   }
 
+  // attribute-specifier-seq
+  if (!TrySkipAttributes())
+    return TPResult::Ambiguous;
+
+  // trailing-return-type
+  if (Tok.is(tok::arrow) && MayHaveTrailingReturnType) {
+    if (TPR == TPResult::True)
+      return TPR;
+    ConsumeToken();
+    if (Tok.is(tok::identifier) && NameAfterArrowIsNonType()) {
+      return TPResult::False;
+    }
+    if (isCXXTypeId(TentativeCXXTypeIdContext::TypeIdInTrailingReturnType))
+      return TPResult::True;
+  }
+
   return TPResult::Ambiguous;
 }
 
+// When parsing an identifier after an arrow it may be a member expression,
+// in which case we should not annotate it as an independant expression
+// so we just lookup that name, if it's not a type the construct is not
+// a function declaration.
+bool Parser::NameAfterArrowIsNonType() {
+  assert(Tok.is(tok::identifier));
+  Token Next = NextToken();
+  if (Next.is(tok::coloncolon))
+    return false;
+  IdentifierInfo *Name = Tok.getIdentifierInfo();
+  SourceLocation NameLoc = Tok.getLocation();
+  CXXScopeSpec SS;
+  TentativeParseCCC CCC(Next);
+  Sema::NameClassification Classification =
+      Actions.ClassifyName(getCurScope(), SS, Name, NameLoc, Next, &CCC);
+  switch (Classification.getKind()) {
+  case Sema::NC_OverloadSet:
+  case Sema::NC_NonType:
+  case Sema::NC_VarTemplate:
+  case Sema::NC_FunctionTemplate:
+    return true;
+  default:
+    break;
+  }
+  return false;
+}
+
 /// '[' constant-expression[opt] ']'
 ///
 Parser::TPResult Parser::TryParseBracketDeclarator() {
   ConsumeBracket();
 
   // A constant-expression cannot begin with a '{', but the
   // expr-or-braced-init-list of a postfix-expression can.
   if (Tok.is(tok::l_brace))

clang/lib/Parse/Parser.cpp

 ///
 /// Note that this routine emits an error if you call it with ::new or ::delete
 /// as the current tokens, so only call it in contexts where these are invalid.
 bool Parser::TryAnnotateTypeOrScopeToken(
     ImplicitTypenameContext AllowImplicitTypename) {
   assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
           Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) ||
           Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) ||
-          Tok.is(tok::kw___super)) &&
+          Tok.is(tok::kw___super) || Tok.is(tok::kw_auto)) &&
          "Cannot be a type or scope token!");
 
   if (Tok.is(tok::kw_typename)) {
     // MSVC lets you do stuff like:
     //   typename typedef T_::D D;
     //
     // We will consume the typedef token here and put it back after we have
     // parsed the first identifier, transforming it into something more like:

clang/test/CXX/drs/dr12xx.cpp

#if __cplusplus >= 201103L
   typedef int V4Int __attribute__((__vector_size__(sizeof(int) * 4)));
   typedef int EV4Int __attribute__((__ext_vector_type__(4)));
   using U = decltype(V4Int()[0]);
   using U = decltype(EV4Int()[0]);
 #endif
 }
 
 #if __cplusplus >= 201103L
+namespace dr1223 { // dr1227: yes open
+struct M;
+template <typename T>
+struct V;
+struct S {
+  S* operator()();
+  int N;
+  int M;
+#if __cplusplus > 202002L
+  template <typename T>
+  static constexpr auto V = 0;
+  void f(char);
+  void f(int);
+  void mem(S s) {
+    auto(s)()->M; //expected-warning {{expression result unused}}
+    auto(s)()->V<int>; //expected-warning {{expression result unused}}
+    auto(s)()->f(0);
+  }
+#endif
+};
+void f(S s) {
+  {
+#if __cplusplus > 202002L
+    auto(s)()->N; //expected-warning {{expression result unused}}
+#endif
+    auto(s)()->M;
+  }
+  {
+    S(s)()->N; //expected-warning {{expression result unused}}
+    S(s)()->M; //expected-warning {{expression result unused}}
+  }
+}
+
+struct A {
+    A(int*);
+    A *operator()();
+};
+typedef struct BB { int C[2]; } *B, C;
+void g() {
+    A a(B ()->C);
+    A b(auto ()->C);
+    static_assert(sizeof(B ()->C[1] == sizeof(int)), "");
+    sizeof(auto () -> C[1]); // expected-error{{function cannot return array type 'C[1]'}}
+}
+
+}
+#endif
+
+#if __cplusplus >= 201103L
 namespace dr1227 { // dr1227: yes
 template <class T> struct A { using X = typename T::X; }; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
 template <class T> typename T::X f(typename A<T>::X);
 template <class T> void f(...) { }
 template <class T> auto g(typename A<T>::X) -> typename T::X; // expected-note {{in instantiation of template class 'dr1227::A<int>' requested here}}
 template <class T> void g(...) { }
 
 void h() {

clang/test/Parser/cxx-ambig-decl-expr.cpp

void arr() {
 
   // These are array declarations.
   int(x[((void)1,1)]); // expected-error {{redefinition}}
   int(x[true ? 1 : (1,1)]); // expected-error {{redefinition}} // expected-warning {{left operand of comma operator has no effect}}
 
   int (*_Atomic atomic_ptr_to_int);
   *atomic_ptr_to_int = 42;
 }
+
+namespace function_with_trailing {
+struct Foo {
+  Foo(int);
+};
+template <typename T> void bar()
+  { Foo _(T::method()->mem()); }
+}

clang/test/Parser/cxx1z-decomposition.cpp

-// RUN: %clang_cc1 -std=c++17 %s -verify -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,cxx17 -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++2b %s -verify=expected,cxx2b -fcxx-exceptions
 // RUN: not %clang_cc1 -std=c++17 %s -emit-llvm-only -fcxx-exceptions
 
 struct S { int a, b, c; };
 
 // A simple-declaration can be a decompsition declaration.
 namespace SimpleDecl {
   auto [a_x, b_x, c_x] = S();
 
void h() {
     }
   }
 }
 
 // Other kinds of declaration cannot.
 namespace OtherDecl {
   // A parameter-declaration is not a simple-declaration.
   // This parses as an array declaration.
-  void f(auto [a, b, c]); // expected-error {{'auto' not allowed in function prototype}} expected-error {{'a'}}
+  void f(auto [a, b, c]); // cxx17-error {{'auto' not allowed in function prototype}} expected-error {{'a'}}
 
   void g() {
     // A condition is allowed as a Clang extension.
     // See commentary in test/Parser/decomposed-condition.cpp
     for (; auto [a, b, c] = S(); ) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
     if (auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
     if (int n; auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
     switch (auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{statement requires expression of integer type ('S' invalid)}}
class A {
     auto [a, b, c] = S(); // expected-error {{not permitted in this context}}
     static auto [a, b, c] = S(); // expected-error {{not permitted in this context}}
   };
 }
 
 namespace GoodSpecifiers {
   void f() {
     int n[1];
-    const volatile auto &[a] = n;
+    const volatile auto &[a] = n; // cxx2b-warning {{volatile qualifier in structured binding declaration is deprecated}}
   }
 }
 
 namespace BadSpecifiers {
   typedef int I1[1];
   I1 n;
   struct S { int n; } s;
   void f() {
     // storage-class-specifiers
-    static auto &[a] = n; // expected-warning {{declared 'static' is a C++20 extension}}
-    thread_local auto &[b] = n; // expected-warning {{declared 'thread_local' is a C++20 extension}}
+    static auto &[a] = n; // cxx17-warning {{declared 'static' is a C++20 extension}}
+    thread_local auto &[b] = n; // cxx17-warning {{declared 'thread_local' is a C++20 extension}}
     extern auto &[c] = n; // expected-error {{cannot be declared 'extern'}} expected-error {{declaration of block scope identifier with linkage cannot have an initializer}}
     struct S {
       mutable auto &[d] = n; // expected-error {{not permitted in this context}}
 
       // function-specifiers
       virtual auto &[e] = n; // expected-error {{not permitted in this context}}
       explicit auto &[f] = n; // expected-error {{not permitted in this context}}
 
       // misc decl-specifiers
       friend auto &[g] = n; // expected-error {{'auto' not allowed}} expected-error {{friends can only be classes or functions}}
     };
     typedef auto &[h] = n; // expected-error {{cannot be declared 'typedef'}}
     constexpr auto &[i] = n; // expected-error {{cannot be declared 'constexpr'}}
   }
 
   static constexpr inline thread_local auto &[j1] = n; // expected-error {{cannot be declared with 'constexpr inline' specifiers}}
-  static thread_local auto &[j2] = n; // expected-warning {{declared with 'static thread_local' specifiers is a C++20 extension}}
+  static thread_local auto &[j2] = n; // cxx17-warning {{declared with 'static thread_local' specifiers is a C++20 extension}}
 
   inline auto &[k] = n; // expected-error {{cannot be declared 'inline'}}
 
   const int K = 5;
+  auto ([c]) = s; // expected-error {{decomposition declaration cannot be declared with parentheses}}
   void g() {
     // defining-type-specifiers other than cv-qualifiers and 'auto'
     S [a] = s; // expected-error {{cannot be declared with type 'S'}}
     decltype(auto) [b] = s; // expected-error {{cannot be declared with type 'decltype(auto)'}}
-    auto ([c]) = s; // expected-error {{cannot be declared with parentheses}}
+    auto ([c2]) = s; // cxx17-error {{decomposition declaration cannot be declared with parenthese}} \
+                     // cxx2b-error {{use of undeclared identifier 'c2'}} \
+                     // cxx2b-error {{expected body of lambda expression}} \
 
     // FIXME: This error is not very good.
     auto [d]() = s; // expected-error {{expected ';'}} expected-error {{expected expression}}
     auto [e][1] = s; // expected-error {{expected ';'}} expected-error {{requires an initializer}}
 
     // FIXME: This should fire the 'misplaced array declarator' diagnostic.
     int [K] arr = {0}; // expected-error {{expected ';'}} expected-error {{cannot be declared with type 'int'}} expected-error {{decomposition declaration '[K]' requires an initializer}}
     int [5] arr = {0}; // expected-error {{place the brackets after the name}}

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

 }
 
 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; }
+void g() { auto(&a)->n = 0; } // cxx23-warning {{before C++23}} \
+                              // cxx20-error {{declaration of variable 'a' with deduced type 'auto (&)' requires an initializer}} \
+                              // cxx20-error {{expected ';' at end of declaration}}
+void h() { auto{&a}->n = 0; } // cxx23-warning {{before C++23}} \
+                              // cxx20-error {{expected unqualified-id}} \
+                              // cxx20-error {{expected expression}}
+
+void e(auto (*p)(int y) -> decltype(y)) {}
+
+struct M;
+struct S{
+    S operator()();
+    S* operator->();
+    int N;
+    int M;
+} s; // expected-note {{here}}
+
+void test() {
+    auto(s)()->N; // cxx23-warning {{expression result unused}} \
+                  // cxx23-warning {{before C++23}} \
+                  // cxx20-error {{unknown type name 'N'}}
+    auto(s)()->M; // expected-error {{redefinition of 's' as different kind of symbol}}
+}
+
+void test_paren() {
+    int a = (auto(0)); // cxx23-warning {{before C++23}} \
+                       // cxx20-error {{expected expression}} \
+                       // cxx20-error {{expected ')'}} \
+                       // cxx20-note  {{to match this '('}}
+    int b = (auto{0}); // cxx23-warning {{before C++23}} \
+                       // cxx20-error {{expected expression}} \
+                       // cxx20-error {{expected ')'}} \
+                       // cxx20-note  {{to match this '('}}
+}