CPlusPlus: Support structured bindings

While we do recommend clangd for modern code bases, we should still be
able to parse basic language constructs.

Fixes: QTCREATORBUG-27975
Change-Id: I189b991685a5cd5f62f2afce77878b60c895e8f9
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: hjk <hjk@qt.io>

src/libs/3rdparty/cplusplus/AST.cpp

@@ -4634,4 +4634,3 @@ int NoExceptOperatorExpressionAST::lastToken() const
         return noexcept_token + 1;
     return 1;
 }
-

src/libs/3rdparty/cplusplus/AST.h

@@ -210,6 +210,7 @@ public:
     virtual DeclarationStatementAST *asDeclarationStatement() { return nullptr; }
     virtual DeclaratorAST *asDeclarator() { return nullptr; }
     virtual DeclaratorIdAST *asDeclaratorId() { return nullptr; }
+    virtual DecompositionDeclaratorAST *asDecompositionDeclarator() { return nullptr; }
     virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return nullptr; }
     virtual DeleteExpressionAST *asDeleteExpression() { return nullptr; }
     virtual DesignatedInitializerAST *asDesignatedInitializer() { return nullptr; }
@@ -1277,6 +1278,24 @@ protected:
     bool match0(AST *, ASTMatcher *) override;
 };
 
+class CPLUSPLUS_EXPORT DecompositionDeclaratorAST: public CoreDeclaratorAST
+{
+public:
+    NameListAST *identifiers = nullptr;
+
+public:
+    DecompositionDeclaratorAST *asDecompositionDeclarator() override { return this; }
+
+    int firstToken() const override { return identifiers->firstToken(); }
+    int lastToken() const override { return identifiers->lastToken(); }
+
+    DecompositionDeclaratorAST *clone(MemoryPool *pool) const override;
+
+protected:
+    void accept0(ASTVisitor *visitor) override;
+    bool match0(AST *, ASTMatcher *) override;
+};
+
 class CPLUSPLUS_EXPORT NestedDeclaratorAST: public CoreDeclaratorAST
 {
 public:

src/libs/3rdparty/cplusplus/ASTClone.cpp

@@ -1840,3 +1840,11 @@ DesignatedInitializerAST *DesignatedInitializerAST::clone(MemoryPool *pool) cons
     return ast;
 }
 
+DecompositionDeclaratorAST *DecompositionDeclaratorAST::clone(MemoryPool *pool) const
+{
+    const auto theClone = new (pool) DecompositionDeclaratorAST;
+    for (NameListAST *iter = identifiers, **ast_iter = &theClone->identifiers;
+         iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
+        *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
+    return theClone;
+}

src/libs/3rdparty/cplusplus/ASTMatch0.cpp

@@ -352,6 +352,14 @@ bool DeclaratorIdAST::match0(AST *pattern, ASTMatcher *matcher)
     return false;
 }
 
+bool DecompositionDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
+{
+    if (DecompositionDeclaratorAST *_other = pattern->asDecompositionDeclarator())
+        return matcher->match(this, _other);
+
+    return false;
+}
+
 bool NestedDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
 {
     if (NestedDeclaratorAST *_other = pattern->asNestedDeclarator())

src/libs/3rdparty/cplusplus/ASTMatcher.cpp

@@ -836,6 +836,15 @@ bool ASTMatcher::match(DeclaratorIdAST *node, DeclaratorIdAST *pattern)
     return true;
 }
 
+bool ASTMatcher::match(DecompositionDeclaratorAST *node, DecompositionDeclaratorAST *pattern)
+{
+    if (!pattern->identifiers)
+        pattern->identifiers = node->identifiers;
+    else if (! AST::match(node->identifiers, pattern->identifiers, this))
+        return false;
+    return true;
+}
+
 bool ASTMatcher::match(NestedDeclaratorAST *node, NestedDeclaratorAST *pattern)
 {
     (void) node;

src/libs/3rdparty/cplusplus/ASTMatcher.h

@@ -63,6 +63,7 @@ public:
     virtual bool match(DeclarationStatementAST *node, DeclarationStatementAST *pattern);
     virtual bool match(DeclaratorAST *node, DeclaratorAST *pattern);
     virtual bool match(DeclaratorIdAST *node, DeclaratorIdAST *pattern);
+    virtual bool match(DecompositionDeclaratorAST *node, DecompositionDeclaratorAST *pattern);
     virtual bool match(DecltypeSpecifierAST *node, DecltypeSpecifierAST *pattern);
     virtual bool match(DeleteExpressionAST *node, DeleteExpressionAST *pattern);
     virtual bool match(DesignatedInitializerAST *node, DesignatedInitializerAST *pattern);

src/libs/3rdparty/cplusplus/ASTPatternBuilder.h

@@ -339,6 +339,13 @@ public:
         return ast;
     }
 
+    DecompositionDeclaratorAST *DecompositionDeclarator(NameListAST *names = nullptr)
+    {
+        const auto ast = new (&pool) DecompositionDeclaratorAST;
+        ast->identifiers = names;
+        return ast;
+    }
+
     NestedDeclaratorAST *NestedDeclarator(DeclaratorAST *declarator = nullptr)
     {
         NestedDeclaratorAST *ast = new (&pool) NestedDeclaratorAST;

src/libs/3rdparty/cplusplus/ASTVisit.cpp

@@ -368,6 +368,14 @@ void DeclaratorIdAST::accept0(ASTVisitor *visitor)
     visitor->endVisit(this);
 }
 
+void DecompositionDeclaratorAST::accept0(ASTVisitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(identifiers, visitor);
+    }
+    visitor->endVisit(this);
+}
+
 void NestedDeclaratorAST::accept0(ASTVisitor *visitor)
 {
     if (visitor->visit(this)) {

src/libs/3rdparty/cplusplus/ASTVisitor.h

@@ -105,6 +105,7 @@ public:
     virtual bool visit(DeclarationStatementAST *) { return true; }
     virtual bool visit(DeclaratorAST *) { return true; }
     virtual bool visit(DeclaratorIdAST *) { return true; }
+    virtual bool visit(DecompositionDeclaratorAST *) { return true; }
     virtual bool visit(DecltypeSpecifierAST *) { return true; }
     virtual bool visit(DeleteExpressionAST *) { return true; }
     virtual bool visit(DesignatedInitializerAST *) { return true; }
@@ -258,6 +259,7 @@ public:
     virtual void endVisit(DeclarationStatementAST *) {}
     virtual void endVisit(DeclaratorAST *) {}
     virtual void endVisit(DeclaratorIdAST *) {}
+    virtual void endVisit(DecompositionDeclaratorAST *) {}
     virtual void endVisit(DecltypeSpecifierAST *) {}
     virtual void endVisit(DeleteExpressionAST *) {}
     virtual void endVisit(DesignatedInitializerAST *) {}

src/libs/3rdparty/cplusplus/ASTfwd.h

@@ -66,6 +66,7 @@ class DeclarationAST;
 class DeclarationStatementAST;
 class DeclaratorAST;
 class DeclaratorIdAST;
+class DecompositionDeclaratorAST;
 class DecltypeSpecifierAST;
 class DeleteExpressionAST;
 class DesignatedInitializerAST;

src/libs/3rdparty/cplusplus/Bind.cpp

@@ -35,6 +35,7 @@
 #include <string>
 #include <memory>
 #include <sstream>
+#include <utility>
 
 using namespace CPlusPlus;
 
@@ -46,6 +47,7 @@ Bind::Bind(TranslationUnit *unit)
       _expression(nullptr),
       _name(nullptr),
       _declaratorId(nullptr),
+      _decompositionDeclarator(nullptr),
       _visibility(Symbol::Public),
       _objcVisibility(Symbol::Public),
       _methodKey(Function::NormalMethod),
@@ -341,7 +343,9 @@ bool Bind::visit(DeclaratorAST *ast)
     return false;
 }
 
-FullySpecifiedType Bind::declarator(DeclaratorAST *ast, const FullySpecifiedType &init, DeclaratorIdAST **declaratorId)
+FullySpecifiedType Bind::declarator(DeclaratorAST *ast, const FullySpecifiedType &init,
+                                    DeclaratorIdAST **declaratorId,
+                                    DecompositionDeclaratorAST **decompDeclarator)
 {
     FullySpecifiedType type = init;
 
@@ -349,6 +353,7 @@ FullySpecifiedType Bind::declarator(DeclaratorAST *ast, const FullySpecifiedType
         return type;
 
     std::swap(_declaratorId, declaratorId);
+    std::swap(_decompositionDeclarator, decompDeclarator);
     bool isAuto = false;
     const bool cxx11Enabled = translationUnit()->languageFeatures().cxx11Enabled;
     if (cxx11Enabled)
@@ -380,6 +385,7 @@ FullySpecifiedType Bind::declarator(DeclaratorAST *ast, const FullySpecifiedType
     }
 
     std::swap(_declaratorId, declaratorId);
+    std::swap(_decompositionDeclarator, decompDeclarator);
     return type;
 }
 
@@ -1997,14 +2003,25 @@ bool Bind::visit(SimpleDeclarationAST *ast)
 
     for (DeclaratorListAST *it = ast->declarator_list; it; it = it->next) {
         DeclaratorIdAST *declaratorId = nullptr;
-        FullySpecifiedType declTy = this->declarator(it->value, type, &declaratorId);
+        DecompositionDeclaratorAST *decompDeclarator = nullptr;
+        FullySpecifiedType declTy = this->declarator(it->value, type, &declaratorId,
+                                                     &decompDeclarator);
 
-        const Name *declName = nullptr;
+        std::vector<std::pair<const Name *, int>> namesAndLocations;
-        int sourceLocation = location(it->value, ast->firstToken());
+        if (declaratorId && declaratorId->name) {
-        if (declaratorId && declaratorId->name)
+            namesAndLocations.push_back({declaratorId->name->name,
-            declName = declaratorId->name->name;
+                                         location(it->value, ast->firstToken())});
+        } else if (decompDeclarator) {
+            for (auto it = decompDeclarator->identifiers->begin();
+                 it != decompDeclarator->identifiers->end(); ++it) {
+                if ((*it)->name)
+                    namesAndLocations.push_back({(*it)->name, (*it)->firstToken()});
+            }
+        }
 
-        Declaration *decl = control()->newDeclaration(sourceLocation, declName);
+        for (const auto &nameAndLoc : qAsConst(namesAndLocations)) {
+            const int sourceLocation = nameAndLoc.second;
+            Declaration *decl = control()->newDeclaration(sourceLocation, nameAndLoc.first);
             decl->setType(declTy);
             setDeclSpecifiers(decl, type);
 
@@ -2018,11 +2035,13 @@ bool Bind::visit(SimpleDeclarationAST *ast)
             }
             else if (declTy.isAuto()) {
                 const ExpressionAST *initializer = it->value->initializer;
-            if (!initializer && declaratorId)
+                if (!initializer && declaratorId) {
-                translationUnit()->error(location(declaratorId->name, ast->firstToken()), "auto-initialized variable must have an initializer");
+                    translationUnit()->error(location(declaratorId->name, ast->firstToken()),
-            else if (initializer)
+                                             "auto-initialized variable must have an initializer");
+                } else if (initializer) {
                     decl->setInitializer(asStringLiteral(initializer));
                 }
+            }
 
             if (_scope->asClass()) {
                 decl->setVisibility(_visibility);
@@ -2043,6 +2062,7 @@ bool Bind::visit(SimpleDeclarationAST *ast)
             *symbolTail = new (translationUnit()->memoryPool()) List<Symbol *>(decl);
             symbolTail = &(*symbolTail)->next;
         }
+    }
     return false;
 }
 
@@ -3319,6 +3339,14 @@ bool Bind::visit(DeclaratorIdAST *ast)
     return false;
 }
 
+bool Bind::visit(DecompositionDeclaratorAST *ast)
+{
+    for (auto it = ast->identifiers->begin(); it != ast->identifiers->end(); ++it)
+        name(*it);
+    *_decompositionDeclarator = ast;
+    return false;
+}
+
 bool Bind::visit(NestedDeclaratorAST *ast)
 {
     _type = this->declarator(ast->declarator, _type, _declaratorId);

src/libs/3rdparty/cplusplus/Bind.h

@@ -77,7 +77,9 @@ protected:
 
     const Name *objCSelectorArgument(ObjCSelectorArgumentAST *ast, bool *hasArg);
     void attribute(GnuAttributeAST *ast);
-    FullySpecifiedType declarator(DeclaratorAST *ast, const FullySpecifiedType &init, DeclaratorIdAST **declaratorId);
+    FullySpecifiedType declarator(DeclaratorAST *ast, const FullySpecifiedType &init,
+                                  DeclaratorIdAST **declaratorId,
+                                  DecompositionDeclaratorAST **decompDeclarator = nullptr);
     void qtInterfaceName(QtInterfaceNameAST *ast);
     void baseSpecifier(BaseSpecifierAST *ast, int colon_token, Class *klass);
     void ctorInitializer(CtorInitializerAST *ast, Function *fun);
@@ -275,6 +277,7 @@ protected:
 
     // CoreDeclaratorAST
     bool visit(DeclaratorIdAST *ast) override;
+    bool visit(DecompositionDeclaratorAST *ast) override;
     bool visit(NestedDeclaratorAST *ast) override;
 
     // PostfixDeclaratorAST
@@ -291,6 +294,7 @@ private:
     const Name *_name;
     FullySpecifiedType _type;
     DeclaratorIdAST **_declaratorId;
+    DecompositionDeclaratorAST **_decompositionDeclarator;
     int _visibility;
     int _objcVisibility;
     int _methodKey;

src/libs/3rdparty/cplusplus/Parser.cpp

@@ -1568,6 +1568,8 @@ bool Parser::parseDeclaratorOrAbstractDeclarator(DeclaratorAST *&node, Specifier
     return parseAbstractDeclarator(node, decl_specifier_list);
 }
 
+
+
 bool Parser::parseCoreDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_specifier_list, ClassSpecifierAST *)
 {
     DEBUG_THIS_RULE();
@@ -1616,11 +1618,51 @@ bool Parser::parseCoreDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_sp
             node = ast;
             return true;
         }
+    } else if (const auto decl = parseDecompositionDeclarator()) {
+        DeclaratorAST *ast = new (_pool) DeclaratorAST;
+        ast->attribute_list = attributes;
+        ast->ptr_operator_list = ptr_operators;
+        ast->core_declarator = decl;
+        node = ast;
+        return true;
     }
     rewind(start);
     return false;
 }
 
+DecompositionDeclaratorAST *Parser::parseDecompositionDeclarator()
+{
+    if (LA() != T_LBRACKET)
+        return nullptr;
+    consumeToken();
+
+    const auto decl = new (_pool) DecompositionDeclaratorAST;
+    for (NameListAST **iter = &decl->identifiers; ; iter = &(*iter)->next) {
+        NameAST *name_ast = nullptr;
+        if (!parseName(name_ast)) {
+            error(cursor(), "expected an identifier");
+            return nullptr;
+        }
+        *iter = new (_pool) NameListAST;
+        (*iter)->value = name_ast;
+
+        if (LA() == T_RBRACKET) {
+            consumeToken();
+            return decl;
+        }
+
+        if (LA() == T_COMMA) {
+            consumeToken();
+            continue;
+        }
+
+        error(cursor(), "expected ',' or ']'");
+        return nullptr;
+    }
+
+    return nullptr;
+}
+
 static bool maybeCppInitializer(DeclaratorAST *declarator)
 {
     if (declarator->ptr_operator_list)

src/libs/3rdparty/cplusplus/Parser.h

@@ -79,6 +79,7 @@ public:
     bool parseSimpleDeclaration(DeclarationAST *&node, ClassSpecifierAST *declaringClass = nullptr);
     bool parseDeclarationStatement(StatementAST *&node);
     bool parseCoreDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_specifier_list, ClassSpecifierAST *declaringClass);
+    DecompositionDeclaratorAST *parseDecompositionDeclarator();
     bool parseDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_specifier_list, ClassSpecifierAST *declaringClass = nullptr);
     bool parseDeleteExpression(ExpressionAST *&node);
     bool parseDoStatement(StatementAST *&node);

src/libs/cplusplus/FindUsages.cpp

@@ -2494,6 +2494,13 @@ bool FindUsages::visit(DeclaratorIdAST *ast)
     return false;
 }
 
+bool FindUsages::visit(DecompositionDeclaratorAST *ast)
+{
+    for (auto it = ast->identifiers->begin(); it != ast->identifiers->end(); ++it)
+        name(*it);
+    return false;
+}
+
 bool FindUsages::visit(NestedDeclaratorAST *ast)
 {
     // unsigned lparen_token = ast->lparen_token;

src/libs/cplusplus/FindUsages.h

@@ -282,6 +282,7 @@ protected:
 
     // CoreDeclaratorAST
     virtual bool visit(DeclaratorIdAST *ast);
+    virtual bool visit(DecompositionDeclaratorAST *ast);
     virtual bool visit(NestedDeclaratorAST *ast);
 
     // PostfixDeclaratorAST

tests/auto/cplusplus/findusages/tst_findusages.cpp

@@ -83,6 +83,7 @@ private Q_SLOTS:
     void shadowedNames_1();
     void shadowedNames_2();
     void staticVariables();
+    void structuredBinding();
 
     void functionNameFoundInArguments();
     void memberFunctionFalsePositives_QTCREATORBUG2176();
@@ -374,6 +375,42 @@ void tst_FindUsages::staticVariables()
     QCOMPARE(findUsages.usages().at(4).type, Usage::Type::Write);
 }
 
+void tst_FindUsages::structuredBinding()
+{
+    const QByteArray src = "\n"
+            "int array[] = {1, 2};\n"
+            "const auto &[e1, e2] = array;\n"
+            "const int i1 = e1;\n"
+            "const int i2 = e2;\n"
+            ;
+    Document::Ptr doc = Document::create("structuredBinding");
+    doc->setUtf8Source(src);
+    doc->parse();
+    doc->check();
+
+    QVERIFY(doc->diagnosticMessages().isEmpty());
+    QCOMPARE(doc->globalSymbolCount(), 5);
+
+    Snapshot snapshot;
+    snapshot.insert(doc);
+
+    Declaration * const d1 = doc->globalSymbolAt(1)->asDeclaration();
+    QVERIFY(d1);
+    Declaration * const d2 = doc->globalSymbolAt(2)->asDeclaration();
+    QVERIFY(d2);
+
+    FindUsages findUsages(src, doc, snapshot, true);
+    findUsages(d1);
+    QCOMPARE(findUsages.usages().size(), 2);
+    QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Initialization);
+    QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
+
+    findUsages(d2);
+    QCOMPARE(findUsages.usages().size(), 2);
+    QCOMPARE(findUsages.usages().at(0).type, Usage::Type::Initialization);
+    QCOMPARE(findUsages.usages().at(1).type, Usage::Type::Read);
+}
+
 void tst_FindUsages::functionNameFoundInArguments()
 {
     const QByteArray src =