qdoc: Correct parsing of the using clause

qdoc could only parse the using clause where the 'using'
keyword was followed by 'namespace'. Now it can parse
using clauses with or without 'namespace'.

Change-Id: Ic4aad025c00b3bda2bc1cbd52d0ba8dbbad653e5
Task-number: QTBUG-44553
Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>
Reviewed-by: Topi Reiniö <topi.reinio@digia.com>

src/tools/qdoc/cppcodeparser.cpp

@@ -1692,35 +1692,76 @@ bool CppCodeParser::matchNamespaceDecl(InnerNode *parent)
     return matched && match(Tok_RightBrace);
 }
 
-bool CppCodeParser::matchUsingDecl()
+/*!
+  Match a C++ \c using clause. Return \c true if the match
+  is successful. Otherwise false.
+
+  If the \c using clause is for a namespace, an open namespace
+  <is inserted for qdoc to look in to find things.
+
+  If the \c using clause is a base class member function, the
+  member function is added to \a parent as an unresolved
+  \c using clause.
+ */
+bool CppCodeParser::matchUsingDecl(InnerNode* parent)
 {
+    bool usingNamespace = false;
     readToken(); // skip 'using'
 
-    // 'namespace'
-    if (tok != Tok_namespace)
-        return false;
-
-    readToken();
-    // identifier
-    if (tok != Tok_Ident)
-        return false;
-
-    QString name;
-    while (tok == Tok_Ident) {
-        name += lexeme();
-        readToken();
-        if (tok == Tok_Semicolon)
-            break;
-        else if (tok != Tok_Gulbrandsen)
-            return false;
-        name += "::";
+    if (tok == Tok_namespace) {
+        usingNamespace = true;
         readToken();
     }
 
-    /*
-        So far, so good. We have 'using namespace Foo;'.
-    */
-    qdb_->insertOpenNamespace(name);
+    int openLeftAngles = 0;
+    int openLeftParens = 0;
+    bool usingOperator = false;
+    QString name;
+    while (tok != Tok_Semicolon) {
+        if ((tok != Tok_Ident) && (tok != Tok_Gulbrandsen)) {
+            if (tok == Tok_LeftAngle) {
+                ++openLeftAngles;
+            }
+            else if (tok == Tok_RightAngle) {
+                if (openLeftAngles <= 0)
+                    return false;
+                --openLeftAngles;
+            }
+            else if (tok == Tok_Comma) {
+                if (openLeftAngles <= 0)
+                    return false;
+            }
+            else if (tok == Tok_operator) {
+                usingOperator = true;
+            }
+            else if (tok == Tok_SomeOperator) {
+                if (!usingOperator)
+                    return false;
+            }
+            else if (tok == Tok_LeftParen) {
+                ++openLeftParens;
+            }
+            else if (tok == Tok_RightParen) {
+                if (openLeftParens <= 0)
+                    return false;
+                --openLeftParens;
+            }
+            else {
+                return false;
+            }
+        }
+        name += lexeme();
+        readToken();
+    }
+
+    if (usingNamespace) {
+        // 'using namespace Foo;'.
+        qdb_->insertOpenNamespace(name);
+    }
+    else if (parent && parent->isClass()) {
+        ClassNode* cn = static_cast<ClassNode*>(parent);
+        cn->addUnresolvedUsingClause(name);
+    }
     return true;
 }
 
@@ -1961,7 +2002,7 @@ bool CppCodeParser::matchDeclList(InnerNode *parent)
             matchNamespaceDecl(parent);
             break;
         case Tok_using:
-            matchUsingDecl();
+            matchUsingDecl(parent);
             break;
         case Tok_template:
             {
@@ -2221,7 +2262,7 @@ bool CppCodeParser::matchDocsAndStuff()
             }
         }
         else if (tok == Tok_using) {
-            matchUsingDecl();
+            matchUsingDecl(0);
         }
         else {
             QStringList parentPath;

src/tools/qdoc/cppcodeparser.h

@@ -127,7 +127,7 @@ protected:
     bool matchClassDecl(InnerNode *parent,
                         const QString &templateStuff = QString());
     bool matchNamespaceDecl(InnerNode *parent);
-    bool matchUsingDecl();
+    bool matchUsingDecl(InnerNode* parent);
     bool matchEnumItem(InnerNode *parent, EnumNode *enume);
     bool matchEnumDecl(InnerNode *parent);
     bool matchTypedefDecl(InnerNode *parent);

src/tools/qdoc/node.cpp

@@ -1414,6 +1414,17 @@ void ClassNode::addUnresolvedBaseClass(Access access,
     bases_.append(RelatedClass(access, path, signature));
 }
 
+/*!
+  Add an unresolved \c using clause to this class node's list
+  of \c using clauses. The unresolved \c using clause will be
+  resolved before the generate phase of qdoc. In an unresolved
+  \c using clause, the pointer to the function node is 0.
+ */
+void ClassNode::addUnresolvedUsingClause(const QString& signature)
+{
+    usingClauses_.append(UsingClause(signature));
+}
+
 /*!
  */
 void ClassNode::fixBaseClasses()

src/tools/qdoc/node.h

@@ -479,6 +479,18 @@ struct RelatedClass
     QString             signature_;
 };
 
+struct UsingClause
+{
+    UsingClause() { }
+    UsingClause(const QString& signature) : node_(0), signature_(signature) { }
+    const QString& signature() const { return signature_; }
+    const Node* node() { return node_; }
+    void setNode(const Node* n) { node_ = n; }
+
+    const Node* node_;
+    QString     signature_;
+};
+
 class ClassNode : public InnerNode
 {
 public:
@@ -493,16 +505,19 @@ public:
     void addResolvedBaseClass(Access access, ClassNode* node);
     void addDerivedClass(Access access, ClassNode* node);
     void addUnresolvedBaseClass(Access access, const QStringList& path, const QString& signature);
+    void addUnresolvedUsingClause(const QString& signature);
     void fixBaseClasses();
     void fixPropertyUsingBaseClasses(PropertyNode* pn);
 
     QList<RelatedClass>& baseClasses() { return bases_; }
     QList<RelatedClass>& derivedClasses() { return derived_; }
     QList<RelatedClass>& ignoredBaseClasses() { return ignoredBases_; }
+    QList<UsingClause>& usingClauses() { return usingClauses_; }
 
     const QList<RelatedClass> &baseClasses() const { return bases_; }
     const QList<RelatedClass> &derivedClasses() const { return derived_; }
     const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases_; }
+    const QList<UsingClause>& usingClauses() const { return usingClauses_; }
 
     QString serviceName() const { return sname; }
     void setServiceName(const QString& value) { sname = value; }
@@ -517,6 +532,7 @@ private:
     QList<RelatedClass> bases_;
     QList<RelatedClass> derived_;
     QList<RelatedClass> ignoredBases_;
+    QList<UsingClause> usingClauses_;
     bool abstract_;
     bool wrapper_;
     QString sname;

src/tools/qdoc/qdocdatabase.cpp

@@ -1331,6 +1331,7 @@ void QDocDatabase::resolveStuff()
     resolveQmlInheritance(primaryTreeRoot());
     //primaryTree()->resolveTargets(primaryTreeRoot());
     primaryTree()->resolveCppToQmlLinks();
+    primaryTree()->resolveUsingClauses();
 }
 
 /*!

src/tools/qdoc/tree.cpp

@@ -498,6 +498,29 @@ void Tree::resolveCppToQmlLinks()
     }
 }
 
+/*!
+  For each C++ class node, resolve any \c using clauses
+  that appeared in the class declaration.
+ */
+void Tree::resolveUsingClauses()
+{
+    foreach (Node* child, root_.childNodes()) {
+        if (child->isClass()) {
+            ClassNode* cn = static_cast<ClassNode*>(child);
+            QList<UsingClause>& usingClauses = cn->usingClauses();
+            QList<UsingClause>::iterator uc = usingClauses.begin();
+            while (uc != usingClauses.end()) {
+                if (!(*uc).node()) {
+                    const Node* n = qdb_->findFunctionNode((*uc).signature(), cn, Node::CPP);
+                    if (n)
+                        (*uc).setNode(n);
+                }
+                ++uc;
+            }
+        }
+    }
+}
+
 /*!
  */
 void Tree::fixInheritance(NamespaceNode* rootNode)
@@ -1427,7 +1450,8 @@ void Tree::insertQmlType(const QString& key, QmlTypeNode* n)
 const Node* Tree::findFunctionNode(const QString& target, const Node* relative, Node::Genus genus)
 {
     QString t = target;
-    t.chop(2);
+    if (t.endsWith("()"))
+        t.chop(2);
     QStringList path = t.split("::");
     const FunctionNode* fn = findFunctionNode(path, relative, SearchBaseClasses, genus);
     if (fn && fn->metaness() != FunctionNode::MacroWithoutParams)

src/tools/qdoc/tree.h

@@ -153,6 +153,7 @@ class Tree
     void resolveInheritanceHelper(int pass, ClassNode* cn);
     void resolveProperties();
     void resolveCppToQmlLinks();
+    void resolveUsingClauses();
     void fixInheritance(NamespaceNode *rootNode = 0);
     NamespaceNode *root() { return &root_; }