Handle qualified name ids.

src/plugins/cpptools/cppfindreferences.cpp

@@ -204,20 +204,26 @@ protected:
 
     virtual bool visit(MemberAccessAST *ast)
     {
-        if (! ast->member_name)
+        if (ast->member_name) {
-            return false;
+            if (SimpleNameAST *simple = ast->member_name->asSimpleName()) {
-
+                if (identifier(simple->identifier_token) == _id) {
-        SimpleNameAST *simple = ast->member_name->asSimpleName();
-        if (! simple)
-            return true; // ### TODO handle pseudo-destructors and qualified names.
-
                     Q_ASSERT(! _postfixExpressionStack.isEmpty());
 
-        if (identifier(simple->identifier_token) == _id) {
+                    checkExpression(_postfixExpressionStack.last()->firstToken(),
-            unsigned startOfPostfixExpression = _postfixExpressionStack.last()->firstToken();
+                                    simple->identifier_token);
 
-            unsigned begin = tokenAt(startOfPostfixExpression).begin();
+                    return false;
-            unsigned end = tokenAt(ast->member_name->lastToken() - 1).end();
+                }
+            }
+        }
+
+        return true;
+    }
+
+    void checkExpression(unsigned startToken, unsigned endToken)
+    {
+        const unsigned begin = tokenAt(startToken).begin();
+        const unsigned end = tokenAt(endToken).end();
 
         const QString expression = _source.mid(begin, end - begin);
         // qDebug() << "*** expression:" << expression;
@@ -226,7 +232,7 @@ protected:
         typeofExpression.setSnapshot(_snapshot);
 
         unsigned line, column;
-            getTokenStartPosition(startOfPostfixExpression, &line, &column);
+        getTokenStartPosition(startToken, &line, &column);
         Symbol *lastVisibleSymbol = _doc->findSymbolAt(line, column);
 
         const QList<TypeOfExpression::Result> results =
@@ -243,26 +249,63 @@ protected:
         }
 
         if (checkCandidates(candidates))
-                reportResult(simple->identifier_token);
+            reportResult(endToken);
-        }
-
-        return false;
     }
 
     virtual bool visit(QualifiedNameAST *ast)
     {
-        if (! ast->name) {
+        for (NestedNameSpecifierAST *nested_name_specifier = ast->nested_name_specifier;
-            //qWarning() << "invalid AST at" << _doc->fileName() << line << column;
+             nested_name_specifier; nested_name_specifier = nested_name_specifier->next) {
-            ast->name = _sem.check(ast, /*scope */ static_cast<Scope *>(0));
+
+            if (NameAST *class_or_namespace_name = nested_name_specifier->class_or_namespace_name) {
+                SimpleNameAST *simple_name = class_or_namespace_name->asSimpleName();
+
+                TemplateIdAST *template_id = 0;
+                if (! simple_name) {
+                    template_id = class_or_namespace_name->asTemplateId();
+
+                    if (template_id) {
+                        for (TemplateArgumentListAST *template_arguments = template_id->template_arguments;
+                             template_arguments; template_arguments = template_arguments->next) {
+                            accept(template_arguments->template_argument);
+                        }
+                    }
                 }
 
-        Q_ASSERT(ast->name != 0);
+                if (simple_name || template_id) {
-        Identifier *id = ast->name->identifier();
+                    const unsigned identifier_token = simple_name
-        if (id == _id && ast->unqualified_name) {
+                               ? simple_name->identifier_token
-            LookupContext context = currentContext(ast);
+                               : template_id->identifier_token;
-            const QList<Symbol *> candidates = context.resolve(ast->name);
+
-            if (checkCandidates(candidates))
+                    if (identifier(identifier_token) == _id)
-                reportResult(ast->unqualified_name->firstToken());
+                        checkExpression(ast->firstToken(), identifier_token);
+                }
+            }
+        }
+
+        if (ast->unqualified_name) {
+            SimpleNameAST *simple_name = ast->unqualified_name->asSimpleName();
+
+            TemplateIdAST *template_id = 0;
+            if (! simple_name) {
+                template_id = ast->unqualified_name->asTemplateId();
+
+                if (template_id) {
+                    for (TemplateArgumentListAST *template_arguments = template_id->template_arguments;
+                         template_arguments; template_arguments = template_arguments->next) {
+                        accept(template_arguments->template_argument);
+                    }
+                }
+            }
+
+            if (simple_name || template_id) {
+                const unsigned identifier_token = simple_name
+                        ? simple_name->identifier_token
+                        : template_id->identifier_token;
+
+                if (identifier(identifier_token) == _id)
+                    checkExpression(ast->firstToken(), identifier_token);
+            }
         }
 
         return false;
@@ -281,6 +324,19 @@ protected:
         return false;
     }
 
+    virtual bool visit(DestructorNameAST *ast)
+    {
+        Identifier *id = identifier(ast->identifier_token);
+        if (id == _id) {
+            LookupContext context = currentContext(ast);
+            const QList<Symbol *> candidates = context.resolve(ast->name);
+            if (checkCandidates(candidates))
+                reportResult(ast->identifier_token);
+        }
+
+        return false;
+    }
+
     virtual bool visit(TemplateIdAST *ast)
     {
         Identifier *id = identifier(ast->identifier_token);
@@ -304,6 +360,7 @@ private:
     Document::Ptr _exprDoc;
     Semantic _sem;
     QList<PostfixExpressionAST *> _postfixExpressionStack;
+    QList<QualifiedNameAST *> _qualifiedNameStack;
 };
 
 } // end of anonymous namespace