qdoc: Teach qdoc to use multiple trees (part 2)

qdoc now knows how to search the forrest of node
trees in an optimal order. But there remain some
problems with specific searches that cross module
boundaries. These include group membership and C++
and QML module membership, as well ass C++ base
class resolution. Part 3 will be concerned with
fixing these remaining bugs.

With this update, qdoc now takes less time to
generate the docs for Qt 5. Testing indicates
that qdoc run time has dropped from about 14
minutes to about 7.5 minutes on an iMac.

Task-number: QTBUG-35377
Change-Id: I6bded6ef54124b4f6e5914cad4548f0b600209b0
Reviewed-by: Martin Smith <[email protected]>

1 files changed, 93 insertions, 63 deletions

diff --git a/src/tools/qdoc/node.cpp b/src/tools/qdoc/node.cpp
index 6399616725e..fcc79ff11c8 100644
--- a/src/tools/qdoc/node.cpp
+++ b/src/tools/qdoc/node.cpp
@@ -764,7 +764,7 @@ void InnerNode::getMemberClasses(NodeMap& out)
   sure to also look in the children of its property
   group nodes. Return the matching node or 0.
  */
-Node *InnerNode::findChildNodeByName(const QString& name) const
+Node *InnerNode::findChildNode(const QString& name) const
 {
     Node *node = childMap.value(name);
     if (node && !node->isQmlPropertyGroup())
@@ -773,7 +773,7 @@ Node *InnerNode::findChildNodeByName(const QString& name) const
         for (int i=0; i<children_.size(); ++i) {
             Node* n = children_.at(i);
             if (n->isQmlPropertyGroup()) {
-                node = static_cast<InnerNode*>(n)->findChildNodeByName(name);
+                node = static_cast<InnerNode*>(n)->findChildNode(name);
                 if (node)
                     return node;
             }
@@ -783,61 +783,6 @@ Node *InnerNode::findChildNodeByName(const QString& name) const
 }
 
 /*!
- */
-void InnerNode::findNodes(const QString& name, QList<Node*>& n)
-{
-    n.clear();
-    Node* node = 0;
-    QList<Node*> nodes = childMap.values(name);
-    /*
-      <sigh> If this node's child map contains no nodes named
-      name, then if this node is a QML class, search each of its
-      property group nodes for a node named name. If a match is
-      found, append it to the output list and return immediately.
-     */
-    if (nodes.isEmpty()) {
-        if (isQmlType()) {
-            for (int i=0; i<children_.size(); ++i) {
-                node = children_.at(i);
-                if (node->isQmlPropertyGroup()) {
-                    node = static_cast<InnerNode*>(node)->findChildNodeByName(name);
-                    if (node) {
-                        n.append(node);
-                        return;
-                    }
-                }
-            }
-        }
-    }
-    else {
-        /*
-          If the childMap does contain one or more nodes named
-          name, traverse the list of matching nodes. Append each
-          matching node that is not a property group node to the
-          output list. Search each property group node for a node
-          named name and append that node to the output list.
-          This is overkill, I think, but should produce a useful
-          list.
-         */
-        for (int i=0; i<nodes.size(); ++i) {
-            node = nodes.at(i);
-            if (!node->isQmlPropertyGroup())
-                n.append(node);
-            else {
-                node = static_cast<InnerNode*>(node)->findChildNodeByName(name);
-                if (node)
-                    n.append(node);
-            }
-        }
-    }
-    if (!n.isEmpty())
-        return;
-    node = primaryFunctionMap.value(name);
-    if (node)
-        n.append(node);
-}
-
-/*!
   Find the node in this node's children that has the given \a name. If
   this node is a QML class node, be sure to also look in the children
   of its property group nodes. Return the matching node or 0. This is
@@ -847,7 +792,7 @@ void InnerNode::findNodes(const QString& name, QList<Node*>& n)
   returns \c true. If \a qml is false, only match a node for which
   node->isQmlNode() returns \c false.
  */
-Node* InnerNode::findChildNodeByName(const QString& name, bool qml) const
+Node* InnerNode::findChildNode(const QString& name, bool qml) const
 {
     QList<Node*> nodes = childMap.values(name);
     if (!nodes.isEmpty()) {
@@ -865,7 +810,7 @@ Node* InnerNode::findChildNodeByName(const QString& name, bool qml) const
         for (int i=0; i<children_.size(); ++i) {
             Node* node = children_.at(i);
             if (node->isQmlPropertyGroup()) {
-                node = static_cast<InnerNode*>(node)->findChildNodeByName(name);
+                node = static_cast<InnerNode*>(node)->findChildNode(name);
                 if (node)
                     return node;
             }
@@ -875,7 +820,7 @@ Node* InnerNode::findChildNodeByName(const QString& name, bool qml) const
 }
 
 /*!
-  This function is like findChildNodeByName(), but if a node
+  This function is like findChildNode(), but if a node
   with the specified \a name is found but it is not of the
   specified \a type, 0 is returned.
 
@@ -885,7 +830,7 @@ Node* InnerNode::findChildNodeByName(const QString& name, bool qml) const
   node because it looks up \a name in the child map, not the
   list.
  */
-Node* InnerNode::findChildNodeByNameAndType(const QString& name, Type type)
+Node* InnerNode::findChildNode(const QString& name, Type type)
 {
     if (type == Function)
         return primaryFunctionMap.value(name);
@@ -901,6 +846,61 @@ Node* InnerNode::findChildNodeByNameAndType(const QString& name, Type type)
 }
 
 /*!
+ */
+void InnerNode::findNodes(const QString& name, QList<Node*>& n)
+{
+    n.clear();
+    Node* node = 0;
+    QList<Node*> nodes = childMap.values(name);
+    /*
+      <sigh> If this node's child map contains no nodes named
+      name, then if this node is a QML class, search each of its
+      property group nodes for a node named name. If a match is
+      found, append it to the output list and return immediately.
+     */
+    if (nodes.isEmpty()) {
+        if (isQmlType()) {
+            for (int i=0; i<children_.size(); ++i) {
+                node = children_.at(i);
+                if (node->isQmlPropertyGroup()) {
+                    node = static_cast<InnerNode*>(node)->findChildNode(name);
+                    if (node) {
+                        n.append(node);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        /*
+          If the childMap does contain one or more nodes named
+          name, traverse the list of matching nodes. Append each
+          matching node that is not a property group node to the
+          output list. Search each property group node for a node
+          named name and append that node to the output list.
+          This is overkill, I think, but should produce a useful
+          list.
+         */
+        for (int i=0; i<nodes.size(); ++i) {
+            node = nodes.at(i);
+            if (!node->isQmlPropertyGroup())
+                n.append(node);
+            else {
+                node = static_cast<InnerNode*>(node)->findChildNode(name);
+                if (node)
+                    n.append(node);
+            }
+        }
+    }
+    if (!n.isEmpty())
+        return;
+    node = primaryFunctionMap.value(name);
+    if (node)
+        n.append(node);
+}
+
+/*!
   Find a function node that is a child of this nose, such
   that the function node has the specified \a name.
  */
@@ -1259,6 +1259,17 @@ void InnerNode::addChild(Node *child)
 }
 
 /*!
+  Adds the \a child to this node's child map using \a title
+  as the key. The \a child is not added to the child list
+  again, because it is presumed to already be there. We just
+  want to be able to find the child by its \a title.
+ */
+void InnerNode::addChild(Node* child, const QString& title)
+{
+    childMap.insertMulti(title, child);
+}
+
+/*!
  */
 void InnerNode::removeChild(Node *child)
 {
@@ -1288,6 +1299,16 @@ void InnerNode::removeChild(Node *child)
         }
         ++ent;
     }
+    if (child->title().isEmpty())
+        return;
+    ent = childMap.find(child->title());
+    while (ent != childMap.end() && ent.key() == child->title()) {
+        if (*ent == child) {
+            childMap.erase(ent);
+            break;
+        }
+        ++ent;
+    }
 }
 
 /*!
@@ -1533,7 +1554,7 @@ void ClassNode::fixPropertyUsingBaseClasses(PropertyNode* pn)
     while (bc != baseClasses().constEnd()) {
         ClassNode* cn = bc->node_;
         if (cn) {
-            Node* n = cn->findChildNodeByNameAndType(pn->name(), Node::Property);
+            Node* n = cn->findChildNode(pn->name(), Node::Property);
             if (n) {
                 PropertyNode* baseProperty = static_cast<PropertyNode*>(n);
                 cn->fixPropertyUsingBaseClasses(baseProperty);
@@ -1552,7 +1573,7 @@ void ClassNode::fixPropertyUsingBaseClasses(PropertyNode* pn)
  */
 PropertyNode* ClassNode::findPropertyNode(const QString& name)
 {
-    Node* n = findChildNodeByNameAndType(name, Node::Property);
+    Node* n = findChildNode(name, Node::Property);
 
     if (n)
         return static_cast<PropertyNode*>(n);
@@ -1666,6 +1687,15 @@ QString DocNode::title() const
 }
 
 /*!
+  Sets the document node's \a title. This is used for the page title.
+ */
+void DocNode::setTitle(const QString &title)
+{
+    title_ = title;
+    parent()->addChild(this, title);
+}
+
+/*!
   Returns the document node's full title, which is usually
   just title(), but for some SubType values is different
   from title()