[pseudo] Eliminate a false parse of structured binding declaration.

[hokein]

Summary

Using the guard to implement part of the rule https://eel.is/c++draft/dcl.pre#6.

void foo() {
  // can be parsed as
  //   - structured-binding declaration (a false parse)
  //   - assignment expression
  array[index] = value;
}

[sammccall]

clang-tools-extra/pseudo/lib/cxx/CXX.cpp

164

nit: specifiesStructuredBinding?
(because the structured binding itself is something bigger)

166

If you're going to iterate over tokens, it seems more direct (and cheaper) to do it directly:
for (const Tok& : P.Tokens.tokens(RHS[0].startTokenIndex(), RHS[1].startTokenIndex()))

clang-tools-extra/pseudo/test/cxx/structured-binding.cpp

2

nit: drop blank line

[hokein]

address comments

clang-tools-extra/pseudo/lib/cxx/CXX.cpp

bool isFunctionDeclarator(const ForestNode *Declarator) {
   }
   llvm_unreachable("unreachable");
 }
 
 bool guardNextTokenNotElse(const GuardParams &P) {
   return symbolToToken(P.Lookahead) != tok::kw_else;
 }
 
+bool specifiesStructuredBinding(const GuardParams &P) {
+  const auto DSS = P.RHS[0];
+  assert(DSS->symbol() == Symbol::decl_specifier_seq);
+
+  auto Length = P.RHS[1]->startTokenIndex() - DSS->startTokenIndex();
+  for (const auto &T :
+       P.Tokens.tokens().slice(DSS->startTokenIndex(), Length)) {
+    switch (T.Kind) {
+    case clang::tok::kw_static:
+    case clang::tok::kw_thread_local:
+    case clang::tok::kw_auto:
+    case clang::tok::kw_const:
+    case clang::tok::kw_volatile:
+      break;
+    default:
+      return false;
+    }
+  }
+  return true;
+}
+
 // Whether this e.g. decl-specifier contains an "exclusive" type such as a class
 // name, and thus can't combine with a second exclusive type.
 //
 // Returns false for
 //  - non-types
 //  - "unsigned" etc that may suffice as types but may modify others
 //  - cases of uncertainty (e.g. due to ambiguity)
 bool hasExclusiveType(const ForestNode *N) {
return {
       // Implement C++ [basic.lookup.qual.general]:
       //   If a name, template-id, or decltype-specifier is followed by a
       //   !::!, it shall designate a namespace, class, enumeration, or
       //   dependent type, and the !::! is never interpreted as a complete
       //   nested-name-specifier.
       {rule::nested_name_specifier::COLONCOLON,
        TOKEN_GUARD(coloncolon, Tok.prev().Kind != tok::identifier)},
 
+      // Implement C++ [dcl.pre#6]:
+      //   A simple-declaration with an identifier-list is called a structured
+      //   binding declaration ([dcl.struct.bind]). If the decl-specifier-seq
+      //   contains any decl-specifier other than static, thread_­local, auto,
+      //   or cv-qualifiers, the program is ill-formed.
+      {rule::simple_declaration::
+           decl_specifier_seq__ref_qualifier__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
+       specifiesStructuredBinding},
+      {rule::simple_declaration::
+           decl_specifier_seq__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
+       specifiesStructuredBinding},
+
       // The grammar distinguishes (only) user-defined vs plain string literals,
       // where the clang lexer distinguishes (only) encoding types.
       {rule::user_defined_string_literal_chunk::STRING_LITERAL,
        TOKEN_GUARD(string_literal, isStringUserDefined(Tok))},
       {rule::user_defined_string_literal_chunk::UTF8_STRING_LITERAL,
        TOKEN_GUARD(utf8_string_literal, isStringUserDefined(Tok))},
       {rule::user_defined_string_literal_chunk::UTF16_STRING_LITERAL,
        TOKEN_GUARD(utf16_string_literal, isStringUserDefined(Tok))},

clang-tools-extra/pseudo/lib/cxx/cxx.bnf

 block-declaration := using-enum-declaration
 block-declaration := using-directive
 block-declaration := static_assert-declaration
 block-declaration := alias-declaration
 block-declaration := opaque-enum-declaration
 nodeclspec-function-declaration := function-declarator ;
 alias-declaration := USING IDENTIFIER = defining-type-id ;
 simple-declaration := decl-specifier-seq init-declarator-list_opt ;
-simple-declaration := decl-specifier-seq ref-qualifier_opt [ identifier-list ] initializer ;
+simple-declaration := decl-specifier-seq ref-qualifier_opt [ identifier-list ] initializer ; [guard]
 static_assert-declaration := STATIC_ASSERT ( constant-expression ) ;
 static_assert-declaration := STATIC_ASSERT ( constant-expression , string-literal ) ;
 empty-declaration := ;
 # dcl.spec
 decl-specifier := storage-class-specifier
 decl-specifier := defining-type-specifier
 decl-specifier := function-specifier
 decl-specifier := FRIEND

clang-tools-extra/pseudo/test/cxx/structured-binding.cpp

+// RUN: clang-pseudo -grammar=cxx -source=%s --start-symbol=statement-seq --print-forest | FileCheck %s
+
+// Verify there is no false parse of the structured binding declaration.
+ABC[post] = abc;
+// CHECK: statement-seq~expression-statement := expression ;
+// CHECK: postfix-expression [ expr-or-braced-init-list ]