qdoc: Avoid unnecessary qdoc warnings

Generates default docs when special class member functions are declared
but not documented, thereby avoiding the "No documentation for..." error.
The member functions now handled are the destructor, the copy constructor,
the move-copy constructor, and the default constructor.

Change-Id: I9ddd7841b1dfec907ab3c2ccd7636dc898df1fce
Task-number: QTBUG-50630
Reviewed-by: Topi Reiniö <topi.reinio@theqtcompany.com>

10 files changed, 116 insertions, 64 deletions

diff --git a/src/qdoc/codemarker.cpp b/src/qdoc/codemarker.cpp
index d1f186e9a..99b9a47c3 100644
--- a/src/qdoc/codemarker.cpp
+++ b/src/qdoc/codemarker.cpp
@@ -368,10 +368,10 @@ QString CodeMarker::sortName(const Node *node, const QString* name)
     if (node->type() == Node::Function) {
         const FunctionNode *func = static_cast<const FunctionNode *>(node);
         QString sortNo;
-        if (func->metaness() == FunctionNode::Ctor) {
+        if (func->isSomeCtor()) {
             sortNo = QLatin1String("C");
         }
-        else if (func->metaness() == FunctionNode::Dtor) {
+        else if (func->isDtor()) {
             sortNo = QLatin1String("D");
         }
         else {
@@ -424,16 +424,13 @@ void CodeMarker::insert(FastSection &fastSection,
     }
     else if (node->type() == Node::Function) {
         FunctionNode *func = (FunctionNode *) node;
-        irrelevant = (inheritedMember
-                      && (func->metaness() == FunctionNode::Ctor ||
-                          func->metaness() == FunctionNode::Dtor));
+        irrelevant = (inheritedMember && (func->isSomeCtor() || func->isDtor()));
     }
-    else if (node->type() == Node::Class || node->type() == Node::Enum
-             || node->type() == Node::Typedef) {
+    else if (node->isClass() || node->isEnumType() || node->isTypedef()) {
         irrelevant = (inheritedMember && style != Subpage);
-        if (!irrelevant && style == Detailed && node->type() == Node::Typedef) {
-            const TypedefNode* typedeffe = static_cast<const TypedefNode*>(node);
-            if (typedeffe->associatedEnum())
+        if (!irrelevant && style == Detailed && node->isTypedef()) {
+            const TypedefNode* tdn = static_cast<const TypedefNode*>(node);
+            if (tdn->associatedEnum())
                 irrelevant = true;
         }
     }
diff --git a/src/qdoc/cppcodeparser.cpp b/src/qdoc/cppcodeparser.cpp
index 29f6a07d4..8e5d279e1 100644
--- a/src/qdoc/cppcodeparser.cpp
+++ b/src/qdoc/cppcodeparser.cpp
@@ -375,7 +375,7 @@ Node* CppCodeParser::processTopicCommand(const Doc& doc,
                 func = 0;
             }
             else {
-                func->setMetaness(FunctionNode::MacroWithParams);
+                func->setMetaness(Node::MacroWithParams);
                 QVector<Parameter> params = func->parameters();
                 for (int i = 0; i < params.size(); ++i) {
                     Parameter &param = params[i];
@@ -391,7 +391,7 @@ Node* CppCodeParser::processTopicCommand(const Doc& doc,
             func = new FunctionNode(qdb_->primaryTreeRoot(), arg.first);
             func->setAccess(Node::Public);
             func->setLocation(doc.startLocation());
-            func->setMetaness(FunctionNode::MacroWithoutParams);
+            func->setMetaness(Node::MacroWithoutParams);
         }
         else {
             doc.location().warning(tr("Invalid syntax in '\\%1'").arg(COMMAND_MACRO));
@@ -1050,7 +1050,7 @@ void CppCodeParser::reset()
     tokenizer = 0;
     tok = 0;
     access = Node::Public;
-    metaness_ = FunctionNode::Plain;
+    metaness_ = Node::Plain;
     lastPath_.clear();
     physicalModuleName.clear();
 }
@@ -1647,12 +1647,24 @@ bool CppCodeParser::matchFunctionDecl(Aggregate *parent,
         if (matched_QT_DEPRECATED)
             func->setStatus(Node::Deprecated);
         if (matched_explicit) { /* What can be done? */ }
+        if (!pvect.isEmpty()) {
+            func->setParameters(pvect);
+        }
         func->setMetaness(metaness_);
         if (parent) {
-            if (name == parent->name())
-                func->setMetaness(FunctionNode::Ctor);
+            if (name == parent->name()) {
+                Node::Metaness m = Node::Ctor;
+                if (!pvect.isEmpty()) {
+                    for (int i=0; i<pvect.size(); i++) {
+                        m = pvect.at(i).metaness(name);
+                        if (m != Node::Ctor)
+                            break;
+                    }
+                }
+                func->setMetaness(m);
+            }
             else if (name.startsWith(QLatin1Char('~')))
-                func->setMetaness(FunctionNode::Dtor);
+                func->setMetaness(Node::Dtor);
         }
         func->setStatic(matched_static);
         func->setConst(matchedConst);
@@ -1662,9 +1674,6 @@ bool CppCodeParser::matchFunctionDecl(Aggregate *parent,
         func->setFinal(matchFinal);
         if (isQPrivateSignal)
             func->setPrivateSignal();
-        if (!pvect.isEmpty()) {
-            func->setParameters(pvect);
-        }
     }
     if (parentPathPtr != 0)
         *parentPathPtr = parentPath;
@@ -1774,8 +1783,8 @@ bool CppCodeParser::matchClassDecl(Aggregate *parent,
 
     Node::Access outerAccess = access;
     access = isClass ? Node::Private : Node::Public;
-    FunctionNode::Metaness outerMetaness = metaness_;
-    metaness_ = FunctionNode::Plain;
+    Node::Metaness outerMetaness = metaness_;
+    metaness_ = Node::Plain;
 
     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
                     match(Tok_Semicolon));
@@ -2156,28 +2165,28 @@ bool CppCodeParser::matchDeclList(Aggregate *parent)
         case Tok_private:
             readToken();
             access = Node::Private;
-            metaness_ = FunctionNode::Plain;
+            metaness_ = Node::Plain;
             break;
         case Tok_protected:
             readToken();
             access = Node::Protected;
-            metaness_ = FunctionNode::Plain;
+            metaness_ = Node::Plain;
             break;
         case Tok_public:
             readToken();
             access = Node::Public;
-            metaness_ = FunctionNode::Plain;
+            metaness_ = Node::Plain;
             break;
         case Tok_signals:
         case Tok_Q_SIGNALS:
             readToken();
             access = Node::Public;
-            metaness_ = FunctionNode::Signal;
+            metaness_ = Node::Signal;
             break;
         case Tok_slots:
         case Tok_Q_SLOTS:
             readToken();
-            metaness_ = FunctionNode::Slot;
+            metaness_ = Node::Slot;
             break;
         case Tok_Q_OBJECT:
             readToken();
@@ -2411,7 +2420,7 @@ bool CppCodeParser::matchDocsAndStuff()
                   generated by moc.
                 */
                 node = qdb_->findFunctionNode(parentPath, clone);
-                if (node != 0 && node->metaness() != FunctionNode::Signal)
+                if (node != 0 && node->metaness() != Node::Signal)
                     node->setLocation(clone->location());
                 delete clone;
             }
diff --git a/src/qdoc/cppcodeparser.h b/src/qdoc/cppcodeparser.h
index 7c110d2bb..4ef8f9e50 100644
--- a/src/qdoc/cppcodeparser.h
+++ b/src/qdoc/cppcodeparser.h
@@ -158,7 +158,7 @@ protected:
     Tokenizer *tokenizer;
     int tok;
     Node::Access access;
-    FunctionNode::Metaness metaness_;
+    Node::Metaness metaness_;
     QString physicalModuleName;
     QStringList lastPath_;
     QRegExp varComment;
diff --git a/src/qdoc/generator.cpp b/src/qdoc/generator.cpp
index c8c2ecefd..460be6454 100644
--- a/src/qdoc/generator.cpp
+++ b/src/qdoc/generator.cpp
@@ -766,6 +766,22 @@ void Generator::generateBody(const Node *node, CodeMarker *marker)
                     text << " The destructor is virtual.";
                 generateText(text, node, marker);
             }
+            else if (func->isCtor()) {
+                Text text;
+                text << "Default constructs an instance of ";
+                text << func->parent()->name() << ".";
+                generateText(text, node, marker);
+            }
+            else if (func->isCCtor()) {
+                Text text;
+                text << "Copy constructor.";
+                generateText(text, node, marker);
+            }
+            else if (func->isMCtor()) {
+                Text text;
+                text << "Move-copy constructor.";
+                generateText(text, node, marker);
+            }
             else if (!node->isWrapper() && !quiet && !node->isReimplemented()) {
                 node->location().warning(tr("No documentation for '%1'").arg(node->plainSignature()));
             }
diff --git a/src/qdoc/helpprojectwriter.cpp b/src/qdoc/helpprojectwriter.cpp
index 1689c0575..7b30aa1ae 100644
--- a/src/qdoc/helpprojectwriter.cpp
+++ b/src/qdoc/helpprojectwriter.cpp
@@ -381,7 +381,7 @@ bool HelpProjectWriter::generateSection(HelpProject &project,
         // Only insert keywords for non-constructors. Constructors are covered
         // by the classes themselves.
 
-        if (funcNode->metaness() != FunctionNode::Ctor)
+        if (!funcNode->isSomeCtor())
             project.keywords.append(keywordDetails(node));
 
         // Insert member status flags into the entries for the parent
diff --git a/src/qdoc/htmlgenerator.cpp b/src/qdoc/htmlgenerator.cpp
index 5e39dd786..0702f0a9b 100644
--- a/src/qdoc/htmlgenerator.cpp
+++ b/src/qdoc/htmlgenerator.cpp
@@ -1498,9 +1498,7 @@ void HtmlGenerator::generateClassLikeNode(Aggregate* inner, CodeMarker* marker)
                 names << (*m)->name();
                 if ((*m)->type() == Node::Function) {
                     const FunctionNode *func = reinterpret_cast<const FunctionNode *>(*m);
-                    if (func->metaness() == FunctionNode::Ctor ||
-                            func->metaness() == FunctionNode::Dtor ||
-                            func->overloadNumber() != 0)
+                    if (func->isSomeCtor() || func->isDtor() || func->overloadNumber() != 0)
                         names.clear();
                 }
                 else if ((*m)->type() == Node::Property) {
diff --git a/src/qdoc/node.cpp b/src/qdoc/node.cpp
index d91d473ce..e8b293011 100644
--- a/src/qdoc/node.cpp
+++ b/src/qdoc/node.cpp
@@ -1952,6 +1952,21 @@ QString Parameter::reconstruct(bool value) const
     return p;
 }
 
+/*!
+  Returns the appropriate metaness value based on the parameter
+  type. The parameter type must contain the \a name and must end
+  with either \c{&&} or \c{&}.
+ */
+Node::Metaness Parameter::metaness(const QString& name) const
+{
+    if (dataType_.contains(name)) {
+        if (dataType_.endsWith(QLatin1String("&&")))
+            return FunctionNode::MCtor;
+        if (dataType_.endsWith(QLatin1String("&")))
+            return FunctionNode::CCtor;
+    }
+    return FunctionNode::Ctor;
+}
 
 /*!
   \class FunctionNode
diff --git a/src/qdoc/node.h b/src/qdoc/node.h
index a2acaf572..481383157 100644
--- a/src/qdoc/node.h
+++ b/src/qdoc/node.h
@@ -155,6 +155,19 @@ public:
         FlagValueTrue = 1
     };
 
+    enum Metaness {
+        Plain,
+        Signal,
+        Slot,
+        Ctor,
+        Dtor,
+        CCtor,
+        MCtor,
+        MacroWithParams,
+        MacroWithoutParams,
+        Native
+    };
+
     virtual ~Node();
 
     QString plainName() const;
@@ -207,6 +220,7 @@ public:
     virtual bool isQmlBasicType() const { return false; }
     virtual bool isJsBasicType() const { return false; }
     virtual bool isEnumType() const { return false; }
+    virtual bool isTypedef() const { return false; }
     virtual bool isExample() const { return false; }
     virtual bool isExampleFile() const { return false; }
     virtual bool isHeaderFile() const { return false; }
@@ -805,6 +819,7 @@ public:
     TypedefNode(Aggregate* parent, const QString& name);
     virtual ~TypedefNode() { }
 
+    virtual bool isTypedef() const { return true; }
     const EnumNode* associatedEnum() const { return associatedEnum_; }
 
 private:
@@ -836,6 +851,7 @@ public:
     void setName(const QString& name) { name_ = name; }
 
     bool hasType() const { return dataType_.length() + rightType_.length() > 0; }
+    Node::Metaness metaness(const QString& name) const;
     const QString& dataType() const { return dataType_; }
     const QString& rightType() const { return rightType_; }
     const QString& name() const { return name_; }
@@ -856,15 +872,6 @@ public:
 class FunctionNode : public LeafNode
 {
 public:
-    enum Metaness {
-        Plain,
-        Signal,
-        Slot,
-        Ctor,
-        Dtor,
-        MacroWithParams,
-        MacroWithoutParams,
-        Native };
     enum Virtualness { NonVirtual, NormalVirtual, PureVirtual };
 
     FunctionNode(Aggregate* parent, const QString &name);
@@ -897,7 +904,11 @@ public:
     bool isOverload() const { return overload_; }
     bool isReimplemented() const Q_DECL_OVERRIDE { return reimplemented_; }
     bool isFunction() const Q_DECL_OVERRIDE { return true; }
+    bool isSomeCtor() const { return isCtor() || isCCtor() || isMCtor(); }
+    bool isCtor() const { return (metaness_ == Ctor); }
+    bool isCCtor() const { return (metaness_ == CCtor); }
     bool isDtor() const { return (metaness_ == Dtor); }
+    bool isMCtor() const { return (metaness_ == MCtor); }
     bool isVirtual() const { return (virtualness_ == NormalVirtual); }
     virtual bool isQmlSignal() const Q_DECL_OVERRIDE {
         return (type() == Node::QmlSignal) && (genus() == Node::QML);
diff --git a/src/qdoc/qdocdatabase.cpp b/src/qdoc/qdocdatabase.cpp
index 5af7867b3..37ccd3220 100644
--- a/src/qdoc/qdocdatabase.cpp
+++ b/src/qdoc/qdocdatabase.cpp
@@ -1049,10 +1049,8 @@ void QDocDatabase::findAllFunctions(Aggregate* node)
             }
             else if ((*c)->type() == Node::Function) {
                 const FunctionNode* func = static_cast<const FunctionNode*>(*c);
-                if ((func->status() > Node::Obsolete) &&
-                        !func->isInternal() &&
-                        (func->metaness() != FunctionNode::Ctor) &&
-                        (func->metaness() != FunctionNode::Dtor)) {
+                if ((func->status() > Node::Obsolete) && !func->isInternal() &&
+                    !func->isSomeCtor() && !func->isDtor()) {
                     funcIndex_[(*c)->name()].insert((*c)->parent()->fullDocumentName(), *c);
                 }
             }
@@ -1226,9 +1224,7 @@ void QDocDatabase::findAllSince(Aggregate* node)
             if ((*child)->type() == Node::Function) {
                 // Insert functions into the general since map.
                 FunctionNode *func = static_cast<FunctionNode *>(*child);
-                if ((func->status() > Node::Obsolete) &&
-                    (func->metaness() != FunctionNode::Ctor) &&
-                    (func->metaness() != FunctionNode::Dtor)) {
+                if ((func->status() > Node::Obsolete) && !func->isSomeCtor() && !func->isDtor()) {
                     nsmap.value().insert(func->name(),(*child));
                 }
             }
diff --git a/src/qdoc/qdocindexfiles.cpp b/src/qdoc/qdocindexfiles.cpp
index f588638fe..ef2c014e9 100644
--- a/src/qdoc/qdocindexfiles.cpp
+++ b/src/qdoc/qdocindexfiles.cpp
@@ -497,23 +497,27 @@ void QDocIndexFiles::readIndexSection(QXmlStreamReader& reader,
             goto done;
 
         t = attributes.value(QLatin1String("meta")).toString();
-        FunctionNode::Metaness meta;
+        Node::Metaness meta;
         if (t == QLatin1String("plain"))
-            meta = FunctionNode::Plain;
+            meta = Node::Plain;
         else if (t == QLatin1String("signal"))
-            meta = FunctionNode::Signal;
+            meta = Node::Signal;
         else if (t == QLatin1String("slot"))
-            meta = FunctionNode::Slot;
+            meta = Node::Slot;
         else if (t == QLatin1String("constructor"))
-            meta = FunctionNode::Ctor;
+            meta = Node::Ctor;
+        else if (t == QLatin1String("copy-constructor"))
+            meta = Node::CCtor;
+        else if (t == QLatin1String("move-constructor"))
+            meta = Node::MCtor;
         else if (t == QLatin1String("destructor"))
-            meta = FunctionNode::Dtor;
+            meta = Node::Dtor;
         else if (t == QLatin1String("macro"))
-            meta = FunctionNode::MacroWithParams;
+            meta = Node::MacroWithParams;
         else if (t == QLatin1String("macrowithparams"))
-            meta = FunctionNode::MacroWithParams;
+            meta = Node::MacroWithParams;
         else if (t == QLatin1String("macrowithoutparams"))
-            meta = FunctionNode::MacroWithoutParams;
+            meta = Node::MacroWithoutParams;
         else
             goto done;
 
@@ -1221,25 +1225,31 @@ bool QDocIndexFiles::generateIndexSection(QXmlStreamWriter& writer,
             }
 
             switch (functionNode->metaness()) {
-            case FunctionNode::Plain:
+            case Node::Plain:
                 writer.writeAttribute("meta", "plain");
                 break;
-            case FunctionNode::Signal:
+            case Node::Signal:
                 writer.writeAttribute("meta", "signal");
                 break;
-            case FunctionNode::Slot:
+            case Node::Slot:
                 writer.writeAttribute("meta", "slot");
                 break;
-            case FunctionNode::Ctor:
+            case Node::Ctor:
                 writer.writeAttribute("meta", "constructor");
                 break;
-            case FunctionNode::Dtor:
+            case Node::CCtor:
+                writer.writeAttribute("meta", "copy-constructor");
+                break;
+            case Node::MCtor:
+                writer.writeAttribute("meta", "move-constructor");
+                break;
+            case Node::Dtor:
                 writer.writeAttribute("meta", "destructor");
                 break;
-            case FunctionNode::MacroWithParams:
+            case Node::MacroWithParams:
                 writer.writeAttribute("meta", "macrowithparams");
                 break;
-            case FunctionNode::MacroWithoutParams:
+            case Node::MacroWithoutParams:
                 writer.writeAttribute("meta", "macrowithoutparams");
                 break;
             default: