From fdbf3bec3009343362448141faa42734ec31b1c3 Mon Sep 17 00:00:00 2001
From: Martin Smith <martin.smith@digia.com>
Date: Wed, 21 Jan 2015 10:18:50 +0100
Subject: qdoc: Change name of node type
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

QmlClassNode is renamed to QmlTypeNode. This is done
in preparation for implementing qdoc support for
documenting javascript code. Next, QmlTypeNode will
be renamed to JsTypeNode, and a new QmlTypeNode will
be declared that will inherit JsTypeNode.

Change-Id: Ia5d0c367d06c26cb43f887927bbcb096afcb7301
Task-number: QTBUG-43715
Reviewed-by: Topi Reiniö <topi.reinio@digia.com>
---
 src/tools/qdoc/codemarker.cpp     |  2 +-
 src/tools/qdoc/codemarker.h       |  6 +++---
 src/tools/qdoc/codeparser.cpp     |  1 +
 src/tools/qdoc/cppcodemarker.cpp  | 12 +++++------
 src/tools/qdoc/cppcodemarker.h    |  2 +-
 src/tools/qdoc/cppcodeparser.cpp  | 10 +++++-----
 src/tools/qdoc/cppcodeparser.h    |  5 +++++
 src/tools/qdoc/doc.cpp            |  2 +-
 src/tools/qdoc/generator.cpp      | 15 ++++++--------
 src/tools/qdoc/generator.h        | 12 +++++------
 src/tools/qdoc/htmlgenerator.cpp  | 22 ++++++++++----------
 src/tools/qdoc/htmlgenerator.h    | 12 +++++------
 src/tools/qdoc/main.cpp           |  1 -
 src/tools/qdoc/node.cpp           | 42 +++++++++++++++++++--------------------
 src/tools/qdoc/node.h             | 26 ++++++++++++------------
 src/tools/qdoc/qdocdatabase.cpp   | 18 ++++++++---------
 src/tools/qdoc/qdocdatabase.h     | 10 +++++-----
 src/tools/qdoc/qdocindexfiles.cpp |  8 ++++----
 src/tools/qdoc/qmlvisitor.cpp     | 16 +++++++--------
 src/tools/qdoc/tree.cpp           | 22 ++++++++++----------
 src/tools/qdoc/tree.h             |  8 ++++----
 21 files changed, 126 insertions(+), 126 deletions(-)

(limited to 'src/tools/qdoc')

diff --git a/src/tools/qdoc/codemarker.cpp b/src/tools/qdoc/codemarker.cpp
index 9a22df4a9f..d6db577962 100644
--- a/src/tools/qdoc/codemarker.cpp
+++ b/src/tools/qdoc/codemarker.cpp
@@ -641,7 +641,7 @@ QString CodeMarker::macName(const Node *node, const QString &name)
 /*!
   Returns an empty list of documentation sections.
  */
-QList<Section> CodeMarker::qmlSections(QmlClassNode* , SynopsisStyle , Status )
+QList<Section> CodeMarker::qmlSections(QmlTypeNode* , SynopsisStyle , Status )
 {
     return QList<Section>();
 }
diff --git a/src/tools/qdoc/codemarker.h b/src/tools/qdoc/codemarker.h
index 8f332de01a..c056906893 100644
--- a/src/tools/qdoc/codemarker.h
+++ b/src/tools/qdoc/codemarker.h
@@ -48,11 +48,11 @@ QT_BEGIN_NAMESPACE
 class Config;
 
 typedef QMultiMap<QString, Node*> MemberMap; // the string is the member signature
-typedef QPair<const QmlClassNode*, MemberMap> ClassMap;    // the node is the QML type
+typedef QPair<const QmlTypeNode*, MemberMap> ClassMap;    // the node is the QML type
 typedef QList<ClassMap*> ClassMapList;
 
 typedef QPair<QStringList, NodeList> KeysAndNodes;
-typedef QPair<const QmlClassNode*, KeysAndNodes> ClassKeysNodes;
+typedef QPair<const QmlTypeNode*, KeysAndNodes> ClassKeysNodes;
 typedef QList<ClassKeysNodes*> ClassKeysNodesList;
 
 struct Section
@@ -146,7 +146,7 @@ public:
     virtual QList<Section> sections(const InnerNode *inner,
                                     SynopsisStyle style,
                                     Status status) = 0;
-    virtual QList<Section> qmlSections(QmlClassNode* qmlClassNode,
+    virtual QList<Section> qmlSections(QmlTypeNode* qmlClassNode,
                                        SynopsisStyle style,
                                        Status status = Okay);
     virtual QStringList macRefsForNode(Node* node);
diff --git a/src/tools/qdoc/codeparser.cpp b/src/tools/qdoc/codeparser.cpp
index acb297d5f9..5a1a6a528e 100644
--- a/src/tools/qdoc/codeparser.cpp
+++ b/src/tools/qdoc/codeparser.cpp
@@ -50,6 +50,7 @@ QT_BEGIN_NAMESPACE
 #define COMMAND_INGROUP                 Doc::alias(QLatin1String("ingroup"))
 #define COMMAND_INMODULE                Doc::alias(QLatin1String("inmodule"))  // ### don't document
 #define COMMAND_INQMLMODULE             Doc::alias(QLatin1String("inqmlmodule"))
+#define COMMAND_INJSMODULE              Doc::alias(QLatin1String("injsmodule"))
 #define COMMAND_INTERNAL                Doc::alias(QLatin1String("internal"))
 #define COMMAND_MAINCLASS               Doc::alias(QLatin1String("mainclass"))
 #define COMMAND_NONREENTRANT            Doc::alias(QLatin1String("nonreentrant"))
diff --git a/src/tools/qdoc/cppcodemarker.cpp b/src/tools/qdoc/cppcodemarker.cpp
index 3851ede16c..c3c486e009 100644
--- a/src/tools/qdoc/cppcodemarker.cpp
+++ b/src/tools/qdoc/cppcodemarker.cpp
@@ -1085,7 +1085,7 @@ QString CppCodeMarker::addMarkUp(const QString &in,
   the list of documentation sections for the children of the
   \a qmlClassNode.
  */
-QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisStyle style, Status status)
+QList<Section> CppCodeMarker::qmlSections(QmlTypeNode* qmlClassNode, SynopsisStyle style, Status status)
 {
     QList<Section> sections;
     if (qmlClassNode) {
@@ -1126,7 +1126,7 @@ QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisSt
                                            "method",
                                            "methods");
 
-            QmlClassNode* qcn = qmlClassNode;
+            QmlTypeNode* qcn = qmlClassNode;
             while (qcn != 0) {
                 NodeList::ConstIterator c = qcn->childNodes().constBegin();
                 while (c != qcn->childNodes().constEnd()) {
@@ -1165,7 +1165,7 @@ QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisSt
                     ++c;
                 }
                 if (qcn->qmlBaseNode() != 0) {
-                    qcn = static_cast<QmlClassNode*>(qcn->qmlBaseNode());
+                    qcn = static_cast<QmlTypeNode*>(qcn->qmlBaseNode());
                     if (!qcn->isAbstract())
                         qcn = 0;
                 }
@@ -1191,7 +1191,7 @@ QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisSt
             FastSection qmlmethods(qmlClassNode,"Method Documentation","qmlmeth","member","members");
             FastSection qmlattachedmethods(qmlClassNode,"Attached Method Documentation","qmlattmeth",
                                            "member","members");
-            QmlClassNode* qcn = qmlClassNode;
+            QmlTypeNode* qcn = qmlClassNode;
             while (qcn != 0) {
                 NodeList::ConstIterator c = qcn->childNodes().constBegin();
                 while (c != qcn->childNodes().constEnd()) {
@@ -1229,7 +1229,7 @@ QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisSt
                     ++c;
                 }
                 if (qcn->qmlBaseNode() != 0) {
-                    qcn = static_cast<QmlClassNode*>(qcn->qmlBaseNode());
+                    qcn = static_cast<QmlTypeNode*>(qcn->qmlBaseNode());
                     if (!qcn->isAbstract())
                         qcn = 0;
                 }
@@ -1251,7 +1251,7 @@ QList<Section> CppCodeMarker::qmlSections(QmlClassNode* qmlClassNode, SynopsisSt
              */
             ClassMap* classMap = 0;
             FastSection all(qmlClassNode,QString(),QString(),"member","members");
-            QmlClassNode* current = qmlClassNode;
+            QmlTypeNode* current = qmlClassNode;
             while (current != 0) {
                 /*
                   If the QML type is abstract, do not create
diff --git a/src/tools/qdoc/cppcodemarker.h b/src/tools/qdoc/cppcodemarker.h
index 899c2018fe..fb2b14d7a4 100644
--- a/src/tools/qdoc/cppcodemarker.h
+++ b/src/tools/qdoc/cppcodemarker.h
@@ -70,7 +70,7 @@ public:
     virtual QList<Section> sections(const InnerNode *innerNode,
                                     SynopsisStyle style,
                                     Status status) Q_DECL_OVERRIDE;
-    virtual QList<Section> qmlSections(QmlClassNode* qmlClassNode,
+    virtual QList<Section> qmlSections(QmlTypeNode* qmlClassNode,
                                        SynopsisStyle style,
                                        Status status = Okay) Q_DECL_OVERRIDE;
 
diff --git a/src/tools/qdoc/cppcodeparser.cpp b/src/tools/qdoc/cppcodeparser.cpp
index 22aae609ae..f05615972c 100644
--- a/src/tools/qdoc/cppcodeparser.cpp
+++ b/src/tools/qdoc/cppcodeparser.cpp
@@ -544,7 +544,7 @@ Node* CppCodeParser::processTopicCommand(const Doc& doc,
                                    tr("Also used here: %1").arg(other));
         }
 #endif
-        QmlClassNode* qcn = new QmlClassNode(qdb_->primaryTreeRoot(), names[0]);
+        QmlTypeNode* qcn = new QmlTypeNode(qdb_->primaryTreeRoot(), names[0]);
         qcn->setClassNode(classNode);
         qcn->setLocation(doc.startLocation());
         return qcn;
@@ -562,7 +562,7 @@ Node* CppCodeParser::processTopicCommand(const Doc& doc,
         QString qmlType;
         QString type;
         if (splitQmlMethodArg(arg.first,type,module,qmlType)) {
-            QmlClassNode* qmlClass = qdb_->findQmlType(module,qmlType);
+            QmlTypeNode* qmlClass = qdb_->findQmlType(module,qmlType);
             if (qmlClass) {
                 bool attached = false;
                 Node::Type nodeType = Node::QmlMethod;
@@ -740,7 +740,7 @@ void CppCodeParser::processQmlProperties(const Doc& doc, NodeList& nodes, DocLis
     QString qmlType;
     QString property;
     QmlPropertyNode* qpn = 0;
-    QmlClassNode* qmlClass = 0;
+    QmlTypeNode* qmlClass = 0;
     QmlPropertyGroupNode* qpgn = 0;
 
     Topic qmlPropertyGroupTopic;
@@ -932,9 +932,9 @@ void CppCodeParser::processOtherMetaCommand(const Doc& doc,
         if (node->name() == arg)
             doc.location().warning(tr("%1 tries to inherit itself").arg(arg));
         else if (node->isQmlType()) {
-            QmlClassNode *qmlClass = static_cast<QmlClassNode*>(node);
+            QmlTypeNode *qmlClass = static_cast<QmlTypeNode*>(node);
             qmlClass->setQmlBaseName(arg);
-            QmlClassNode::addInheritedBy(arg,node);
+            QmlTypeNode::addInheritedBy(arg,node);
         }
     }
     else if (command == COMMAND_QMLINSTANTIATES) {
diff --git a/src/tools/qdoc/cppcodeparser.h b/src/tools/qdoc/cppcodeparser.h
index 03b55c7775..f70f7937b8 100644
--- a/src/tools/qdoc/cppcodeparser.h
+++ b/src/tools/qdoc/cppcodeparser.h
@@ -234,6 +234,11 @@ protected:
 #define COMMAND_LICENSEDESCRIPTION      Doc::alias("licensedescription")
 #define COMMAND_RELEASEDATE             Doc::alias("releasedate")
 #define COMMAND_QTVARIABLE              Doc::alias("qtvariable")
+#define COMMAND_JSTYPE                  Doc::alias("jstype")
+#define COMMAND_JSPROPERTY              Doc::alias("jsproperty")
+#define COMMAND_JSMETHOD                Doc::alias("jsmethod")
+#define COMMAND_JSSIGNAL                Doc::alias("jssignal")
+#define COMMAND_JSMODULE                Doc::alias("jsmodule")
 
 QT_END_NAMESPACE
 
diff --git a/src/tools/qdoc/doc.cpp b/src/tools/qdoc/doc.cpp
index c10e3b4669..613dbd95c3 100644
--- a/src/tools/qdoc/doc.cpp
+++ b/src/tools/qdoc/doc.cpp
@@ -3146,7 +3146,7 @@ void Doc::initialize(const Config& config)
     DocParser::sourceDirs = config.getCanonicalPathList(CONFIG_SOURCEDIRS);
     DocParser::quoting = config.getBool(CONFIG_QUOTINGINFORMATION);
 
-    QmlClassNode::qmlOnly = config.getBool(CONFIG_QMLONLY);
+    QmlTypeNode::qmlOnly = config.getBool(CONFIG_QMLONLY);
     QStringMap reverseAliasMap;
     config_ = &config;
 
diff --git a/src/tools/qdoc/generator.cpp b/src/tools/qdoc/generator.cpp
index 614ba37f49..6c606e828a 100644
--- a/src/tools/qdoc/generator.cpp
+++ b/src/tools/qdoc/generator.cpp
@@ -95,7 +95,7 @@ Generator::QDocPass Generator::qdocPass_ = Generator::Neither;
 bool Generator::qdocSingleExec_ = false;
 bool Generator::qdocWriteQaPages_ = false;
 bool Generator::useOutputSubdirs_ = true;
-QmlClassNode* Generator::qmlTypeContext_ = 0;
+QmlTypeNode* Generator::qmlTypeContext_ = 0;
 
 void Generator::startDebugging(const QString& message)
 {
@@ -963,9 +963,6 @@ void Generator::generateInherits(const ClassNode *classe, CodeMarker *marker)
 
 /*!
   Recursive writing of HTML files from the root \a node.
-
-  \note DitaXmlGenerator overrides this function, but
-  HtmlGenerator does not.
  */
 void Generator::generateInnerNode(InnerNode* node)
 {
@@ -1003,7 +1000,7 @@ void Generator::generateInnerNode(InnerNode* node)
         }
         if (node->isQmlType()) {
             beginSubPage(node, fileName(node));
-            QmlClassNode* qcn = static_cast<QmlClassNode*>(node);
+            QmlTypeNode* qcn = static_cast<QmlTypeNode*>(node);
             generateQmlTypePage(qcn, marker);
             endSubPage();
         }
@@ -1084,12 +1081,12 @@ void Generator::generateMaintainerList(const InnerNode* node, CodeMarker* marker
   Output the "Inherit by" list for the QML element,
   if it is inherited by any other elements.
  */
-void Generator::generateQmlInheritedBy(const QmlClassNode* qcn,
+void Generator::generateQmlInheritedBy(const QmlTypeNode* qcn,
                                               CodeMarker* marker)
 {
     if (qcn) {
         NodeList subs;
-        QmlClassNode::subclasses(qcn->name(),subs);
+        QmlTypeNode::subclasses(qcn->name(),subs);
         if (!subs.isEmpty()) {
             Text text;
             text << Atom::ParaLeft << "Inherited by ";
@@ -1102,7 +1099,7 @@ void Generator::generateQmlInheritedBy(const QmlClassNode* qcn,
 
 /*!
  */
-void Generator::generateQmlInherits(QmlClassNode* , CodeMarker* )
+void Generator::generateQmlInherits(QmlTypeNode* , CodeMarker* )
 {
     // stub.
 }
@@ -1924,7 +1921,7 @@ void Generator::terminate()
     imageFiles.clear();
     imageDirs.clear();
     outDir_.clear();
-    QmlClassNode::terminate();
+    QmlTypeNode::terminate();
 }
 
 void Generator::terminateGenerator()
diff --git a/src/tools/qdoc/generator.h b/src/tools/qdoc/generator.h
index d0c38bcb40..774be6cd38 100644
--- a/src/tools/qdoc/generator.h
+++ b/src/tools/qdoc/generator.h
@@ -101,8 +101,8 @@ public:
     static QString defaultModuleName() { return project_; }
     static void resetUseOutputSubdirs() { useOutputSubdirs_ = false; }
     static bool useOutputSubdirs() { return useOutputSubdirs_; }
-    static void setQmlTypeContext(QmlClassNode* t) { qmlTypeContext_ = t; }
-    static QmlClassNode* qmlTypeContext() { return qmlTypeContext_; }
+    static void setQmlTypeContext(QmlTypeNode* t) { qmlTypeContext_ = t; }
+    static QmlTypeNode* qmlTypeContext() { return qmlTypeContext_; }
 
 protected:
     virtual void beginSubPage(const InnerNode* node, const QString& fileName);
@@ -114,7 +114,7 @@ protected:
     virtual int generateAtom(const Atom *atom, const Node *relative, CodeMarker *marker);
     virtual void generateBody(const Node *node, CodeMarker *marker);
     virtual void generateClassLikeNode(InnerNode* inner, CodeMarker* marker);
-    virtual void generateQmlTypePage(QmlClassNode* , CodeMarker* ) { }
+    virtual void generateQmlTypePage(QmlTypeNode* , CodeMarker* ) { }
     virtual void generateQmlBasicTypePage(QmlBasicTypeNode* , CodeMarker* ) { }
     virtual void generateDocNode(DocNode* dn, CodeMarker* marker);
     virtual void generateCollectionNode(CollectionNode* cn, CodeMarker* marker);
@@ -122,8 +122,8 @@ protected:
     virtual void generateInherits(const ClassNode *classe, CodeMarker *marker);
     virtual void generateInnerNode(InnerNode* node);
     virtual void generateMaintainerList(const InnerNode* node, CodeMarker* marker);
-    virtual void generateQmlInheritedBy(const QmlClassNode* qcn, CodeMarker* marker);
-    virtual void generateQmlInherits(QmlClassNode* qcn, CodeMarker* marker);
+    virtual void generateQmlInheritedBy(const QmlTypeNode* qcn, CodeMarker* marker);
+    virtual void generateQmlInherits(QmlTypeNode* qcn, CodeMarker* marker);
     virtual bool generateQmlText(const Text& text,
                                  const Node *relative,
                                  CodeMarker *marker,
@@ -223,7 +223,7 @@ private:
     static bool qdocSingleExec_;
     static bool qdocWriteQaPages_;
     static bool useOutputSubdirs_;
-    static QmlClassNode* qmlTypeContext_;
+    static QmlTypeNode* qmlTypeContext_;
 
     void generateReimplementedFrom(const FunctionNode *func, CodeMarker *marker);
 
diff --git a/src/tools/qdoc/htmlgenerator.cpp b/src/tools/qdoc/htmlgenerator.cpp
index 22c44bd7f6..fddb53dff1 100644
--- a/src/tools/qdoc/htmlgenerator.cpp
+++ b/src/tools/qdoc/htmlgenerator.cpp
@@ -1530,7 +1530,7 @@ void HtmlGenerator::generateClassLikeNode(InnerNode* inner, CodeMarker* marker)
   Generate the HTML page for a QML type. \qcn is the QML type.
   \marker is the code markeup object.
  */
-void HtmlGenerator::generateQmlTypePage(QmlClassNode* qcn, CodeMarker* marker)
+void HtmlGenerator::generateQmlTypePage(QmlTypeNode* qcn, CodeMarker* marker)
 {
     Generator::setQmlTypeContext(qcn);
     SubTitleSize subTitleSize = LargeSubTitle;
@@ -2218,7 +2218,7 @@ void HtmlGenerator::generateRequisites(InnerNode *inner, CodeMarker *marker)
 Lists the required imports and includes in a table.
 The number of rows is known, so this path is simpler than the generateSection() path.
 */
-void HtmlGenerator::generateQmlRequisites(QmlClassNode *qcn, CodeMarker *marker)
+void HtmlGenerator::generateQmlRequisites(QmlTypeNode *qcn, CodeMarker *marker)
 {
     if (!qcn)
         return;
@@ -2280,7 +2280,7 @@ void HtmlGenerator::generateQmlRequisites(QmlClassNode *qcn, CodeMarker *marker)
     }
 
     //add the inherits to the map
-    QmlClassNode* base = qcn->qmlBaseNode();
+    QmlTypeNode* base = qcn->qmlBaseNode();
     while (base && base->isInternal()) {
         base = base->qmlBaseNode();
     }
@@ -2297,7 +2297,7 @@ void HtmlGenerator::generateQmlRequisites(QmlClassNode *qcn, CodeMarker *marker)
 
     //add the inherited-by to the map
     NodeList subs;
-    QmlClassNode::subclasses(qcn->name(), subs);
+    QmlTypeNode::subclasses(qcn->name(), subs);
     if (!subs.isEmpty()) {
         text.clear();
         text << Atom::ParaLeft;
@@ -2541,7 +2541,7 @@ QString HtmlGenerator::generateListOfAllMemberFile(const InnerNode *inner,
   the members of QML class \a qml_cn, including the inherited
   members. The \a marker is used for formatting stuff.
  */
-QString HtmlGenerator::generateAllQmlMembersFile(QmlClassNode* qml_cn, CodeMarker* marker)
+QString HtmlGenerator::generateAllQmlMembersFile(QmlTypeNode* qml_cn, CodeMarker* marker)
 {
     QList<Section> sections;
     QList<Section>::ConstIterator s;
@@ -2564,7 +2564,7 @@ QString HtmlGenerator::generateAllQmlMembersFile(QmlClassNode* qml_cn, CodeMarke
     if (!cknl.isEmpty()) {
         for (int i=0; i<cknl.size(); i++) {
             ClassKeysNodes* ckn = cknl[i];
-            const QmlClassNode* qcn = ckn->first;
+            const QmlTypeNode* qcn = ckn->first;
             KeysAndNodes& kn = ckn->second;
             QStringList& keys = kn.first;
             NodeList& nodes = kn.second;
@@ -2690,7 +2690,7 @@ QString HtmlGenerator::generateLowStatusMemberFile(InnerNode *inner,
   Note that this function currently only handles correctly the
   case where \a status is \c {CodeMarker::Obsolete}.
  */
-QString HtmlGenerator::generateQmlMemberFile(QmlClassNode* qcn,
+QString HtmlGenerator::generateQmlMemberFile(QmlTypeNode* qcn,
                                              CodeMarker *marker,
                                              CodeMarker::Status status)
 {
@@ -4345,11 +4345,11 @@ void HtmlGenerator::generateDetailedQmlMember(Node *node,
   Output the "Inherits" line for the QML element,
   if there should be one.
  */
-void HtmlGenerator::generateQmlInherits(QmlClassNode* qcn, CodeMarker* marker)
+void HtmlGenerator::generateQmlInherits(QmlTypeNode* qcn, CodeMarker* marker)
 {
     if (!qcn)
         return;
-    QmlClassNode* base = qcn->qmlBaseNode();
+    QmlTypeNode* base = qcn->qmlBaseNode();
     while (base && base->isInternal()) {
         base = base->qmlBaseNode();
     }
@@ -4372,7 +4372,7 @@ void HtmlGenerator::generateQmlInherits(QmlClassNode* qcn, CodeMarker* marker)
   If there is no class node, or if the class node status
   is set to Node::Internal, do nothing.
  */
-void HtmlGenerator::generateQmlInstantiates(QmlClassNode* qcn, CodeMarker* marker)
+void HtmlGenerator::generateQmlInstantiates(QmlTypeNode* qcn, CodeMarker* marker)
 {
     ClassNode* cn = qcn->classNode();
     if (cn && (cn->status() != Node::Internal)) {
@@ -4409,7 +4409,7 @@ void HtmlGenerator::generateQmlInstantiates(QmlClassNode* qcn, CodeMarker* marke
 void HtmlGenerator::generateInstantiatedBy(ClassNode* cn, CodeMarker* marker)
 {
     if (cn &&  cn->status() != Node::Internal && cn->qmlElement() != 0) {
-        const QmlClassNode* qcn = cn->qmlElement();
+        const QmlTypeNode* qcn = cn->qmlElement();
         Text text;
         text << Atom::ParaLeft;
         text << Atom(Atom::LinkNode,CodeMarker::stringForNode(cn));
diff --git a/src/tools/qdoc/htmlgenerator.h b/src/tools/qdoc/htmlgenerator.h
index 4d93822db1..5c0e21dad2 100644
--- a/src/tools/qdoc/htmlgenerator.h
+++ b/src/tools/qdoc/htmlgenerator.h
@@ -96,7 +96,7 @@ protected:
                              const Node *relative,
                              CodeMarker *marker) Q_DECL_OVERRIDE;
     virtual void generateClassLikeNode(InnerNode* inner, CodeMarker* marker) Q_DECL_OVERRIDE;
-    virtual void generateQmlTypePage(QmlClassNode* qcn, CodeMarker* marker) Q_DECL_OVERRIDE;
+    virtual void generateQmlTypePage(QmlTypeNode* qcn, CodeMarker* marker) Q_DECL_OVERRIDE;
     virtual void generateQmlBasicTypePage(QmlBasicTypeNode* qbtn, CodeMarker* marker) Q_DECL_OVERRIDE;
     virtual void generateDocNode(DocNode* dn, CodeMarker* marker) Q_DECL_OVERRIDE;
     virtual void generateCollectionNode(CollectionNode* cn, CodeMarker* marker) Q_DECL_OVERRIDE;
@@ -139,7 +139,7 @@ private:
     void generateFooter(const Node *node = 0);
     void generateRequisites(InnerNode *inner,
                             CodeMarker *marker);
-    void generateQmlRequisites(QmlClassNode *qcn,
+    void generateQmlRequisites(QmlTypeNode *qcn,
                             CodeMarker *marker);
     void generateBrief(const Node *node,
                        CodeMarker *marker,
@@ -151,11 +151,11 @@ private:
     void generateSidebar();
     QString generateListOfAllMemberFile(const InnerNode *inner,
                                         CodeMarker *marker);
-    QString generateAllQmlMembersFile(QmlClassNode* qml_cn, CodeMarker* marker);
+    QString generateAllQmlMembersFile(QmlTypeNode* qml_cn, CodeMarker* marker);
     QString generateLowStatusMemberFile(InnerNode *inner,
                                         CodeMarker *marker,
                                         CodeMarker::Status status);
-    QString generateQmlMemberFile(QmlClassNode* qcn,
+    QString generateQmlMemberFile(QmlTypeNode* qcn,
                                   CodeMarker *marker,
                                   CodeMarker::Status status);
     void generateClassHierarchy(const Node *relative, NodeMap &classMap);
@@ -183,8 +183,8 @@ private:
     void generateDetailedQmlMember(Node *node,
                                    const InnerNode *relative,
                                    CodeMarker *marker);
-    void generateQmlInherits(QmlClassNode* qcn, CodeMarker* marker) Q_DECL_OVERRIDE;
-    void generateQmlInstantiates(QmlClassNode* qcn, CodeMarker* marker);
+    void generateQmlInherits(QmlTypeNode* qcn, CodeMarker* marker) Q_DECL_OVERRIDE;
+    void generateQmlInstantiates(QmlTypeNode* qcn, CodeMarker* marker);
     void generateInstantiatedBy(ClassNode* cn, CodeMarker* marker);
 
     void generateRequisitesTable(const QStringList& requisitesOrder, QMap<QString, Text>& requisites);
diff --git a/src/tools/qdoc/main.cpp b/src/tools/qdoc/main.cpp
index 443d3e7288..51b60222c3 100644
--- a/src/tools/qdoc/main.cpp
+++ b/src/tools/qdoc/main.cpp
@@ -594,7 +594,6 @@ int main(int argc, char **argv)
     QmlCodeMarker qmlMarker;
 
     HtmlGenerator htmlGenerator;
-    //DitaXmlGenerator ditaxmlGenerator;
 
     QCommandLineParser parser;
     parser.setApplicationDescription(QCoreApplication::translate("qdoc", "Qt documentation generator"));
diff --git a/src/tools/qdoc/node.cpp b/src/tools/qdoc/node.cpp
index 6e291e0e65..1bc1ebe92c 100644
--- a/src/tools/qdoc/node.cpp
+++ b/src/tools/qdoc/node.cpp
@@ -628,14 +628,14 @@ QString Node::guid() const
   If it is a child of a QML class node, return a pointer to
   the QML class node. Otherwise, return 0;
  */
-QmlClassNode* Node::qmlClassNode()
+QmlTypeNode* Node::qmlClassNode()
 {
     if (isQmlNode()) {
         Node* n = this;
         while (n && !n->isQmlType())
             n = n->parent();
         if (n && n->isQmlType())
-            return static_cast<QmlClassNode*>(n);
+            return static_cast<QmlTypeNode*>(n);
     }
     return 0;
 }
@@ -649,7 +649,7 @@ QmlClassNode* Node::qmlClassNode()
  */
 ClassNode* Node::declarativeCppNode()
 {
-    QmlClassNode* qcn = qmlClassNode();
+    QmlTypeNode* qcn = qmlClassNode();
     if (qcn)
         return qcn->classNode();
     return 0;
@@ -1614,9 +1614,9 @@ PropertyNode* ClassNode::findPropertyNode(const QString& name)
   finds one, it returns the pointer to that QML element. If
   it doesn't find one, it returns null.
  */
-QmlClassNode* ClassNode::findQmlBaseNode()
+QmlTypeNode* ClassNode::findQmlBaseNode()
 {
-    QmlClassNode* result = 0;
+    QmlTypeNode* result = 0;
     const QList<RelatedClass>& bases = baseClasses();
 
     if (!bases.isEmpty()) {
@@ -2133,14 +2133,14 @@ QString PropertyNode::qualifiedDataType() const
     }
 }
 
-bool QmlClassNode::qmlOnly = false;
-QMultiMap<QString,Node*> QmlClassNode::inheritedBy;
+bool QmlTypeNode::qmlOnly = false;
+QMultiMap<QString,Node*> QmlTypeNode::inheritedBy;
 
 /*!
   Constructs a Qml class node. The new node has the given
   \a parent and \a name.
  */
-QmlClassNode::QmlClassNode(InnerNode *parent, const QString& name)
+QmlTypeNode::QmlTypeNode(InnerNode *parent, const QString& name)
     : InnerNode(QmlType, parent, name),
       abstract_(false),
       cnodeRequired_(false),
@@ -2161,7 +2161,7 @@ QmlClassNode::QmlClassNode(InnerNode *parent, const QString& name)
 /*!
   Needed for printing a debug messages.
  */
-QmlClassNode::~QmlClassNode()
+QmlTypeNode::~QmlTypeNode()
 {
     // nothing.
 }
@@ -2170,7 +2170,7 @@ QmlClassNode::~QmlClassNode()
   Clear the static maps so that subsequent runs don't try to use
   contents from a previous run.
  */
-void QmlClassNode::terminate()
+void QmlTypeNode::terminate()
 {
     inheritedBy.clear();
 }
@@ -2179,7 +2179,7 @@ void QmlClassNode::terminate()
   Record the fact that QML class \a base is inherited by
   QML class \a sub.
  */
-void QmlClassNode::addInheritedBy(const QString& base, Node* sub)
+void QmlTypeNode::addInheritedBy(const QString& base, Node* sub)
 {
     if (inheritedBy.constFind(base,sub) == inheritedBy.constEnd()) {
         inheritedBy.insert(base,sub);
@@ -2189,7 +2189,7 @@ void QmlClassNode::addInheritedBy(const QString& base, Node* sub)
 /*!
   Loads the list \a subs with the nodes of all the subclasses of \a base.
  */
-void QmlClassNode::subclasses(const QString& base, NodeList& subs)
+void QmlTypeNode::subclasses(const QString& base, NodeList& subs)
 {
     subs.clear();
     if (inheritedBy.count(base) > 0) {
@@ -2220,7 +2220,7 @@ void QmlModuleNode::setQmlModuleInfo(const QString& arg)
     }
 }
 
-QmlClassNode* QmlClassNode::qmlBaseNode()
+QmlTypeNode* QmlTypeNode::qmlBaseNode()
 {
     if (!qmlBaseNode_ && !qmlBaseName_.isEmpty()) {
         qmlBaseNode_ = QDocDatabase::qdocDB()->findQmlType(qmlBaseName_);
@@ -2233,7 +2233,7 @@ QmlClassNode* QmlClassNode::qmlBaseNode()
   return the fully qualified name of that QML
   type, i.e. <QML-module-name>::<QML-type-name>.
  */
-QString QmlClassNode::qmlFullBaseName() const
+QString QmlTypeNode::qmlFullBaseName() const
 {
     QString result;
     if (qmlBaseNode_) {
@@ -2247,7 +2247,7 @@ QString QmlClassNode::qmlFullBaseName() const
   module name from the QML module node. Otherwise, return the
   empty string.
  */
-QString QmlClassNode::qmlModuleName() const
+QString QmlTypeNode::qmlModuleName() const
 {
     return (qmlModule_ ? qmlModule_->qmlModuleName() : QString());
 }
@@ -2257,7 +2257,7 @@ QString QmlClassNode::qmlModuleName() const
   module version from the QML module node. Otherwise, return
   the empty string.
  */
-QString QmlClassNode::qmlModuleVersion() const
+QString QmlTypeNode::qmlModuleVersion() const
 {
     return (qmlModule_ ? qmlModule_->qmlModuleVersion() : QString());
 }
@@ -2267,7 +2267,7 @@ QString QmlClassNode::qmlModuleVersion() const
   module identifier from the QML module node. Otherwise, return
   the empty string.
  */
-QString QmlClassNode::qmlModuleIdentifier() const
+QString QmlTypeNode::qmlModuleIdentifier() const
 {
     return (qmlModule_ ? qmlModule_->qmlModuleIdentifier() : QString());
 }
@@ -2285,9 +2285,9 @@ QmlBasicTypeNode::QmlBasicTypeNode(InnerNode *parent,
 
 /*!
   Constructor for the Qml property group node. \a parent is
-  always a QmlClassNode.
+  always a QmlTypeNode.
  */
-QmlPropertyGroupNode::QmlPropertyGroupNode(QmlClassNode* parent, const QString& name)
+QmlPropertyGroupNode::QmlPropertyGroupNode(QmlTypeNode* parent, const QString& name)
     : InnerNode(QmlPropertyGroup, parent, name)
 {
     idNumber_ = -1;
@@ -2347,7 +2347,7 @@ bool QmlPropertyNode::isWritable()
     if (readOnly_ != FlagValueDefault)
         return !fromFlagValue(readOnly_, false);
 
-    QmlClassNode* qcn = qmlClassNode();
+    QmlTypeNode* qcn = qmlClassNode();
     if (qcn) {
         if (qcn->cppClassRequired()) {
             if (qcn->classNode()) {
@@ -2381,7 +2381,7 @@ PropertyNode* QmlPropertyNode::findCorrespondingCppProperty()
     while (n && !n->isQmlType())
         n = n->parent();
     if (n) {
-        QmlClassNode* qcn = static_cast<QmlClassNode*>(n);
+        QmlTypeNode* qcn = static_cast<QmlTypeNode*>(n);
         ClassNode* cn = qcn->classNode();
         if (cn) {
             /*
diff --git a/src/tools/qdoc/node.h b/src/tools/qdoc/node.h
index 7defa10cc3..6fd4cbf83c 100644
--- a/src/tools/qdoc/node.h
+++ b/src/tools/qdoc/node.h
@@ -51,7 +51,7 @@ class ClassNode;
 class InnerNode;
 class ExampleNode;
 class TypedefNode;
-class QmlClassNode;
+class QmlTypeNode;
 class QDocDatabase;
 class FunctionNode;
 class PropertyNode;
@@ -300,7 +300,7 @@ public:
     virtual void setClassNode(ClassNode* ) { }
     virtual const Node* applyModuleName(const Node* ) const { return 0; }
     virtual QString idNumber() { return "0"; }
-    QmlClassNode* qmlClassNode();
+    QmlTypeNode* qmlClassNode();
     ClassNode* declarativeCppNode();
     const QString& outputSubdirectory() const { return outSubDir_; }
     void setOutputSubdirectory(const QString& t) { outSubDir_ = t; }
@@ -493,12 +493,12 @@ public:
 
     QString serviceName() const { return sname; }
     void setServiceName(const QString& value) { sname = value; }
-    QmlClassNode* qmlElement() { return qmlelement; }
-    void setQmlElement(QmlClassNode* qcn) { qmlelement = qcn; }
+    QmlTypeNode* qmlElement() { return qmlelement; }
+    void setQmlElement(QmlTypeNode* qcn) { qmlelement = qcn; }
     virtual bool isAbstract() const Q_DECL_OVERRIDE { return abstract_; }
     virtual void setAbstract(bool b) Q_DECL_OVERRIDE { abstract_ = b; }
     PropertyNode* findPropertyNode(const QString& name);
-    QmlClassNode* findQmlBaseNode();
+    QmlTypeNode* findQmlBaseNode();
 
 private:
     QList<RelatedClass> bases_;
@@ -508,7 +508,7 @@ private:
     bool wrapper_;
     QString sname;
     QString obsoleteLink_;
-    QmlClassNode* qmlelement;
+    QmlTypeNode* qmlelement;
 };
 
 class DocNode : public InnerNode
@@ -578,11 +578,11 @@ struct ImportRec {
 
 typedef QList<ImportRec> ImportList;
 
-class QmlClassNode : public InnerNode
+class QmlTypeNode : public InnerNode
 {
 public:
-    QmlClassNode(InnerNode* parent, const QString& name);
-    virtual ~QmlClassNode();
+    QmlTypeNode(InnerNode* parent, const QString& name);
+    virtual ~QmlTypeNode();
     virtual bool isQmlNode() const Q_DECL_OVERRIDE { return true; }
     virtual bool isQmlType() const Q_DECL_OVERRIDE { return true; }
     virtual bool isQtQuickNode() const Q_DECL_OVERRIDE { return (qmlModuleName() == QLatin1String("QtQuick")); }
@@ -607,8 +607,8 @@ public:
     const QString& qmlBaseName() const { return qmlBaseName_; }
     void setQmlBaseName(const QString& name) { qmlBaseName_ = name; }
     bool qmlBaseNodeNotSet() const { return (qmlBaseNode_ == 0); }
-    QmlClassNode* qmlBaseNode();
-    void setQmlBaseNode(QmlClassNode* b) { qmlBaseNode_ = b; }
+    QmlTypeNode* qmlBaseNode();
+    void setQmlBaseNode(QmlTypeNode* b) { qmlBaseNode_ = b; }
     void requireCppClass() { cnodeRequired_ = true; }
     bool cppClassRequired() const { return cnodeRequired_; }
     static void addInheritedBy(const QString& base, Node* sub);
@@ -627,7 +627,7 @@ private:
     QString             qmlBaseName_;
     QString             obsoleteLink_;
     QmlModuleNode*      qmlModule_;
-    QmlClassNode*       qmlBaseNode_;
+    QmlTypeNode*       qmlBaseNode_;
     ImportList          importList_;
 };
 
@@ -645,7 +645,7 @@ public:
 class QmlPropertyGroupNode : public InnerNode
 {
 public:
-    QmlPropertyGroupNode(QmlClassNode* parent, const QString& name);
+    QmlPropertyGroupNode(QmlTypeNode* parent, const QString& name);
     virtual ~QmlPropertyGroupNode() { }
     virtual bool isQmlNode() const Q_DECL_OVERRIDE { return true; }
     virtual bool isQtQuickNode() const Q_DECL_OVERRIDE { return parent()->isQtQuickNode(); }
diff --git a/src/tools/qdoc/qdocdatabase.cpp b/src/tools/qdoc/qdocdatabase.cpp
index a2c1b82c7f..bf9baf2282 100644
--- a/src/tools/qdoc/qdocdatabase.cpp
+++ b/src/tools/qdoc/qdocdatabase.cpp
@@ -734,9 +734,9 @@ void QDocDatabase::initializeDB()
   Looks up the QML type node identified by the qualified Qml
   type \a name and returns a pointer to the QML type node.
  */
-QmlClassNode* QDocDatabase::findQmlType(const QString& name)
+QmlTypeNode* QDocDatabase::findQmlType(const QString& name)
 {
-    QmlClassNode* qcn = forest_.lookupQmlType(name);
+    QmlTypeNode* qcn = forest_.lookupQmlType(name);
     if (qcn)
         return qcn;
     return 0;
@@ -750,11 +750,11 @@ QmlClassNode* QDocDatabase::findQmlType(const QString& name)
   If the QML module id is empty, it looks up the QML type by
   \a name only.
  */
-QmlClassNode* QDocDatabase::findQmlType(const QString& qmid, const QString& name)
+QmlTypeNode* QDocDatabase::findQmlType(const QString& qmid, const QString& name)
 {
     if (!qmid.isEmpty()) {
         QString t = qmid + "::" + name;
-        QmlClassNode* qcn = forest_.lookupQmlType(t);
+        QmlTypeNode* qcn = forest_.lookupQmlType(t);
         if (qcn)
             return qcn;
     }
@@ -762,7 +762,7 @@ QmlClassNode* QDocDatabase::findQmlType(const QString& qmid, const QString& name
     QStringList path(name);
     Node* n = forest_.findNodeByNameAndType(path, Node::QmlType);
     if (n && n->isQmlType())
-        return static_cast<QmlClassNode*>(n);
+        return static_cast<QmlTypeNode*>(n);
     return 0;
 }
 
@@ -772,7 +772,7 @@ QmlClassNode* QDocDatabase::findQmlType(const QString& qmid, const QString& name
   QML type \a name and returns a pointer to the QML type node.
   If a QML type node is not found, 0 is returned.
  */
-QmlClassNode* QDocDatabase::findQmlType(const ImportRec& import, const QString& name)
+QmlTypeNode* QDocDatabase::findQmlType(const ImportRec& import, const QString& name)
 {
     if (!import.isEmpty()) {
         QStringList dotSplit;
@@ -784,7 +784,7 @@ QmlClassNode* QDocDatabase::findQmlType(const ImportRec& import, const QString&
             qmName = import.importUri_;
         for (int i=0; i<dotSplit.size(); ++i) {
             QString qualifiedName = qmName + "::" + dotSplit[i];
-            QmlClassNode* qcn = forest_.lookupQmlType(qualifiedName);
+            QmlTypeNode* qcn = forest_.lookupQmlType(qualifiedName);
             if (qcn)
                 return qcn;
         }
@@ -1398,9 +1398,9 @@ void QDocDatabase::resolveQmlInheritance(InnerNode* root)
     // Do we need recursion?
     foreach (Node* child, root->childNodes()) {
         if (child->isQmlType()) {
-            QmlClassNode* qcn = static_cast<QmlClassNode*>(child);
+            QmlTypeNode* qcn = static_cast<QmlTypeNode*>(child);
             if (qcn->qmlBaseNodeNotSet() && !qcn->qmlBaseName().isEmpty()) {
-                QmlClassNode* bqcn = static_cast<QmlClassNode*>(previousSearches.value(qcn->qmlBaseName()));
+                QmlTypeNode* bqcn = static_cast<QmlTypeNode*>(previousSearches.value(qcn->qmlBaseName()));
                 if (bqcn)
                     qcn->setQmlBaseNode(bqcn);
                 else {
diff --git a/src/tools/qdoc/qdocdatabase.h b/src/tools/qdoc/qdocdatabase.h
index bc7a912740..f1e4fee46f 100644
--- a/src/tools/qdoc/qdocdatabase.h
+++ b/src/tools/qdoc/qdocdatabase.h
@@ -177,10 +177,10 @@ class QDocForest
         return 0;
     }
 
-    QmlClassNode* lookupQmlType(const QString& name)
+    QmlTypeNode* lookupQmlType(const QString& name)
     {
         foreach (Tree* t, searchOrder()) {
-            QmlClassNode* qcn = t->lookupQmlType(name);
+            QmlTypeNode* qcn = t->lookupQmlType(name);
             if (qcn)
                 return qcn;
         }
@@ -255,9 +255,9 @@ class QDocDatabase
     void addExampleNode(ExampleNode* n) { primaryTree()->addExampleNode(n); }
     ExampleNodeMap& exampleNodeMap() { return primaryTree()->exampleNodeMap(); }
 
-    QmlClassNode* findQmlType(const QString& name);
-    QmlClassNode* findQmlType(const QString& qmid, const QString& name);
-    QmlClassNode* findQmlType(const ImportRec& import, const QString& name);
+    QmlTypeNode* findQmlType(const QString& name);
+    QmlTypeNode* findQmlType(const QString& qmid, const QString& name);
+    QmlTypeNode* findQmlType(const ImportRec& import, const QString& name);
 
  private:
     void findAllClasses(InnerNode *node);
diff --git a/src/tools/qdoc/qdocindexfiles.cpp b/src/tools/qdoc/qdocindexfiles.cpp
index e152b04ead..01a3efcaca 100644
--- a/src/tools/qdoc/qdocindexfiles.cpp
+++ b/src/tools/qdoc/qdocindexfiles.cpp
@@ -208,7 +208,7 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
         node->setAbstract(abstract);
     }
     else if (element.nodeName() == "qmlclass") {
-        QmlClassNode* qcn = new QmlClassNode(parent, name);
+        QmlTypeNode* qcn = new QmlTypeNode(parent, name);
         qcn->setTitle(element.attribute("title"));
         QString qmlModuleName = element.attribute("qml-module-name");
         if (!qmlModuleName.isEmpty())
@@ -241,7 +241,7 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
         node = qbtn;
     }
     else if (element.nodeName() == "qmlpropertygroup") {
-        QmlClassNode* qcn = static_cast<QmlClassNode*>(parent);
+        QmlTypeNode* qcn = static_cast<QmlTypeNode*>(parent);
         QmlPropertyGroupNode* qpgn = new QmlPropertyGroupNode(qcn, name);
         if (element.hasAttribute("location"))
             name = element.attribute("location", QString());
@@ -261,7 +261,7 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
             readonly = true;
         QmlPropertyNode* qpn = 0;
         if (parent->isQmlType()) {
-            QmlClassNode* qcn = static_cast<QmlClassNode*>(parent);
+            QmlTypeNode* qcn = static_cast<QmlTypeNode*>(parent);
             qpn = new QmlPropertyNode(qcn, name, type, attached);
         }
         else if (parent->isQmlPropertyGroup()) {
@@ -881,7 +881,7 @@ bool QDocIndexFiles::generateIndexSection(QXmlStreamWriter& writer,
         break;
     case Node::QmlType:
         {
-            const QmlClassNode* qcn = static_cast<const QmlClassNode*>(node);
+            const QmlTypeNode* qcn = static_cast<const QmlTypeNode*>(node);
             writer.writeAttribute("title", qcn->title());
             writer.writeAttribute("fulltitle", qcn->fullTitle());
             writer.writeAttribute("subtitle", qcn->subTitle());
diff --git a/src/tools/qdoc/qmlvisitor.cpp b/src/tools/qdoc/qmlvisitor.cpp
index 9ef5bab5e2..a621973b81 100644
--- a/src/tools/qdoc/qmlvisitor.cpp
+++ b/src/tools/qdoc/qmlvisitor.cpp
@@ -371,9 +371,9 @@ void QmlDocVisitor::applyMetacommands(QQmlJS::AST::SourceLocation,
                 if (node->name() == args[0].first)
                     doc.location().warning(tr("%1 tries to inherit itself").arg(args[0].first));
                 else if (node->isQmlType()) {
-                    QmlClassNode *qmlClass = static_cast<QmlClassNode*>(node);
+                    QmlTypeNode *qmlClass = static_cast<QmlTypeNode*>(node);
                     qmlClass->setQmlBaseName(args[0].first);
-                    QmlClassNode::addInheritedBy(args[0].first,node);
+                    QmlTypeNode::addInheritedBy(args[0].first,node);
                 }
             }
             else if (command == COMMAND_QMLDEFAULT) {
@@ -452,12 +452,12 @@ bool QmlDocVisitor::visit(QQmlJS::AST::UiObjectDefinition *definition)
     nestingLevel++;
 
     if (current->type() == Node::Namespace) {
-        QmlClassNode *component = new QmlClassNode(current, name);
+        QmlTypeNode *component = new QmlTypeNode(current, name);
         component->setTitle(name);
         component->setImportList(importList);
         importList.clear();
         if (applyDocumentation(definition->firstSourceLocation(), component)) {
-            QmlClassNode::addInheritedBy(type, component);
+            QmlTypeNode::addInheritedBy(type, component);
             component->setQmlBaseName(type);
         }
         current = component;
@@ -533,7 +533,7 @@ bool QmlDocVisitor::visit(QQmlJS::AST::UiPublicMember *member)
     case QQmlJS::AST::UiPublicMember::Signal:
     {
         if (current->isQmlType()) {
-            QmlClassNode *qmlClass = static_cast<QmlClassNode *>(current);
+            QmlTypeNode *qmlClass = static_cast<QmlTypeNode *>(current);
             if (qmlClass) {
 
                 QString name = member->name.toString();
@@ -556,7 +556,7 @@ bool QmlDocVisitor::visit(QQmlJS::AST::UiPublicMember *member)
         QString type = member->memberType.toString();
         QString name = member->name.toString();
         if (current->isQmlType()) {
-            QmlClassNode *qmlClass = static_cast<QmlClassNode *>(current);
+            QmlTypeNode *qmlClass = static_cast<QmlTypeNode *>(current);
             if (qmlClass) {
                 QString name = member->name.toString();
                 QmlPropertyNode* qmlPropNode = qmlClass->hasQmlProperty(name);
@@ -600,7 +600,7 @@ bool QmlDocVisitor::visit(QQmlJS::AST::FunctionDeclaration* fd)
         return true;
     }
     if (current->isQmlType()) {
-        QmlClassNode* qmlClass = static_cast<QmlClassNode*>(current);
+        QmlTypeNode* qmlClass = static_cast<QmlTypeNode*>(current);
         if (qmlClass) {
             QString name = fd->name.toString();
             FunctionNode* qmlMethod = new FunctionNode(Node::QmlMethod, current, name, false);
@@ -655,7 +655,7 @@ bool QmlDocVisitor::visit(QQmlJS::AST::UiScriptBinding* )
     if (current->isQmlType()) {
         QString handler = sb->qualifiedId->name.toString();
         if (handler.length() > 2 && handler.startsWith("on") && handler.at(2).isUpper()) {
-            QmlClassNode* qmlClass = static_cast<QmlClassNode*>(current);
+            QmlTypeNode* qmlClass = static_cast<QmlTypeNode*>(current);
             if (qmlClass) {
                 FunctionNode* qmlSH = new FunctionNode(Node::QmlSignalHandler,current,handler,false);
                 applyDocumentation(sb->firstSourceLocation(), qmlSH);
diff --git a/src/tools/qdoc/tree.cpp b/src/tools/qdoc/tree.cpp
index 9e52099205..5c7a2143e9 100644
--- a/src/tools/qdoc/tree.cpp
+++ b/src/tools/qdoc/tree.cpp
@@ -188,7 +188,7 @@ FunctionNode* Tree::findFunctionNode(const QStringList& parentPath, const Functi
   at the root of the tree. Only a Qml type node named <\a path is
   acceptible. If one is not found, 0 is returned.
  */
-QmlClassNode* Tree::findQmlTypeNode(const QStringList& path)
+QmlTypeNode* Tree::findQmlTypeNode(const QStringList& path)
 {
     /*
       If the path contains one or two double colons ("::"),
@@ -199,11 +199,11 @@ QmlClassNode* Tree::findQmlTypeNode(const QStringList& path)
       class node.
     */
     if (path.size() >= 2 && !path[0].isEmpty()) {
-        QmlClassNode* qcn = qdb_->findQmlType(path[0], path[1]);
+        QmlTypeNode* qcn = qdb_->findQmlType(path[0], path[1]);
         if (qcn)
             return qcn;
     }
-    return static_cast<QmlClassNode*>(findNodeRecursive(path, 0, root(), Node::QmlType));
+    return static_cast<QmlTypeNode*>(findNodeRecursive(path, 0, root(), Node::QmlType));
 }
 
 /*!
@@ -221,12 +221,12 @@ const FunctionNode* Tree::findFunctionNode(const QStringList& path,
 {
     if (path.size() == 3 && !path[0].isEmpty() &&
         ((genus == Node::QML) || (genus == Node::DontCare))) {
-        QmlClassNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
+        QmlTypeNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
         if (!qcn) {
             QStringList p(path[1]);
             Node* n = findNodeByNameAndType(p, Node::QmlType);
             if (n && n->isQmlType())
-                qcn = static_cast<QmlClassNode*>(n);
+                qcn = static_cast<QmlTypeNode*>(n);
         }
         if (qcn)
             return static_cast<const FunctionNode*>(qcn->findFunctionNode(path[2]));
@@ -490,7 +490,7 @@ void Tree::resolveCppToQmlLinks()
 
     foreach (Node* child, root_.childNodes()) {
         if (child->isQmlType()) {
-            QmlClassNode* qcn = static_cast<QmlClassNode*>(child);
+            QmlTypeNode* qcn = static_cast<QmlTypeNode*>(child);
             ClassNode* cn = const_cast<ClassNode*>(qcn->classNode());
             if (cn)
                 cn->setQmlElement(qcn);
@@ -731,7 +731,7 @@ const Node* Tree::findNodeForTarget(const QStringList& path,
     int path_idx = 0;
     if (((genus == Node::QML) || (genus == Node::DontCare)) &&
         (path.size() >= 2) && !path[0].isEmpty()) {
-        QmlClassNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
+        QmlTypeNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
         if (qcn) {
             current = qcn;
             if (path.size() == 2) {
@@ -876,7 +876,7 @@ const Node* Tree::findNode(const QStringList& path,
         */
         if (((genus == Node::QML) || (genus == Node::DontCare)) &&
             (path.size() >= 2) && !path[0].isEmpty()) {
-            QmlClassNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
+            QmlTypeNode* qcn = lookupQmlType(QString(path[0] + "::" + path[1]));
             if (qcn) {
                 node = qcn;
                 if (path.size() == 2)
@@ -1374,7 +1374,7 @@ QmlModuleNode* Tree::addToQmlModule(const QString& name, Node* node)
     qmn->addMember(node);
     node->setQmlModule(qmn);
     if (node->isQmlType()) {
-        QmlClassNode* n = static_cast<QmlClassNode*>(node);
+        QmlTypeNode* n = static_cast<QmlTypeNode*>(node);
         for (int i=0; i<qmid.size(); ++i) {
             QString key = qmid[i] + "::" + node->name();
             insertQmlType(key, n);
@@ -1387,7 +1387,7 @@ QmlModuleNode* Tree::addToQmlModule(const QString& name, Node* node)
   If the QML type map does not contain \a key, insert node
   \a n with the specified \a key.
  */
-void Tree::insertQmlType(const QString& key, QmlClassNode* n)
+void Tree::insertQmlType(const QString& key, QmlTypeNode* n)
 {
     if (!qmlTypeMap_.contains(key))
         qmlTypeMap_.insert(key,n);
@@ -1396,8 +1396,6 @@ void Tree::insertQmlType(const QString& key, QmlClassNode* n)
 /*!
   Split \a target on "::" and find the function node with that
   path.
-
-  Called in HtmlGenerator, DitaXmlGenerator, and QdocDatabase.
  */
 const Node* Tree::findFunctionNode(const QString& target, const Node* relative, Node::Genus genus)
 {
diff --git a/src/tools/qdoc/tree.h b/src/tools/qdoc/tree.h
index 6ccf85371b..677e473bd9 100644
--- a/src/tools/qdoc/tree.h
+++ b/src/tools/qdoc/tree.h
@@ -81,7 +81,7 @@ struct TargetLoc
 
 typedef QMultiMap<QString, TargetRec*> TargetMap;
 typedef QMultiMap<QString, DocNode*> DocNodeMultiMap;
-typedef QMap<QString, QmlClassNode*> QmlTypeMap;
+typedef QMap<QString, QmlTypeNode*> QmlTypeMap;
 typedef QMultiMap<QString, const ExampleNode*> ExampleNodeMap;
 typedef QVector<TargetLoc*> TargetList;
 typedef QMap<QString, TargetList*> TargetListMap;
@@ -132,7 +132,7 @@ class Tree
                          int findFlags,            // = 0,
                          Node::Genus genus) const; // = Node::DontCare) const;
 
-    QmlClassNode* findQmlTypeNode(const QStringList& path);
+    QmlTypeNode* findQmlTypeNode(const QStringList& path);
 
     Node* findNodeByNameAndType(const QStringList& path, Node::Type type) const;
     InnerNode* findRelatesNode(const QStringList& path);
@@ -196,8 +196,8 @@ class Tree
     ModuleNode* addToModule(const QString& name, Node* node);
     QmlModuleNode* addToQmlModule(const QString& name, Node* node);
 
-    QmlClassNode* lookupQmlType(const QString& name) const { return qmlTypeMap_.value(name); }
-    void insertQmlType(const QString& key, QmlClassNode* n);
+    QmlTypeNode* lookupQmlType(const QString& name) const { return qmlTypeMap_.value(name); }
+    void insertQmlType(const QString& key, QmlTypeNode* n);
     void addExampleNode(ExampleNode* n) { exampleNodeMap_.insert(n->title(), n); }
     ExampleNodeMap& exampleNodeMap() { return exampleNodeMap_; }
     const Node* checkForCollision(const QString& name);
-- 
cgit v1.2.3