Generate modern C++ code with nullptr and override

This mostly works, there are only a few cases where the override is missing for virtual destructors.
I still wanted to commit my work, since I will currently not work further on it.

Author: usiems

generator/abstractmetabuilder.cpp

@@ -1303,6 +1303,7 @@ void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scope_item, AbstractM
                 if (!meta_function->isPublic()) {
                   meta_class->setHasPublicDestructor(false);
                 }
+                meta_class->setHasVirtualDestructor(meta_function->isVirtual());
             }
         }
     }
@@ -1407,8 +1408,11 @@ bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *meta_class)
         if (types->isClassRejected(base_classes.at(i)))
             continue;
 
+        AbstractMetaClass *base_class = m_meta_classes.findClass(base_classes.at(i));
+        if (base_class) {
+            meta_class->addSuperClass(base_class);
+        }
         if (i != primary) {
-            AbstractMetaClass *base_class = m_meta_classes.findClass(base_classes.at(i));
             if (base_class == 0) {
                 ReportHandler::warning(QString("class not found for setup inheritance '%1'").arg(base_classes.at(i)));
                 return false;

generator/abstractmetalang.cpp

@@ -1173,6 +1173,23 @@ QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) cons
     return 0;
 }
 
+bool AbstractMetaClass::hasVirtualDestructor() const
+{
+    if (m_has_virtual_destructor) {
+        return true;
+    }
+    else {
+        // check all super classes
+        for (int i = 0; i < m_super_classes.size(); ++i) {
+            AbstractMetaClass* super_class = m_super_classes.at(i);
+            if (super_class->hasVirtualDestructor()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 
 
 static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)

generator/abstractmetalang.h

@@ -674,6 +674,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
           m_has_nonprivateconstructor(false),
           m_functions_fixed(false),
           m_has_public_destructor(true),
+          m_has_virtual_destructor(false),
           m_force_shell_class(false),
           m_has_hash_function(false),
           m_has_equals_operator(false),
@@ -709,6 +710,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
     void setHasNonPrivateConstructor(bool on) { m_has_nonprivateconstructor = on; }
     bool hasPublicDestructor() const { return m_has_public_destructor; }
     void setHasPublicDestructor(bool on) { m_has_public_destructor = on; }
+    bool hasVirtualDestructor() const;
+    void setHasVirtualDestructor(bool on) { m_has_virtual_destructor = on; }
 
     QString destructorException() const { return m_destructor_exception; }
     void setDestructorException(const QString &exception) { m_destructor_exception = exception; }
@@ -749,6 +752,10 @@ class AbstractMetaClass : public AbstractMetaAttributes
     AbstractMetaClass *baseClass() const { return m_base_class; }
     void setBaseClass(AbstractMetaClass *base_class) { m_base_class = base_class; }
 
+    // this lists _all_ super classes of this class
+    QList<AbstractMetaClass *> superClasses() const { return m_super_classes; }
+    void addSuperClass(AbstractMetaClass *super_class) { m_super_classes.append(super_class); }
+
     const AbstractMetaClass *enclosingClass() const { return m_enclosing_class; }
     void setEnclosingClass(AbstractMetaClass *cl) { m_enclosing_class = cl; }
 
@@ -849,16 +856,18 @@ class AbstractMetaClass : public AbstractMetaAttributes
     uint m_has_nonprivateconstructor : 1;
     uint m_functions_fixed : 1;
     uint m_has_public_destructor : 1;
+    uint m_has_virtual_destructor : 1;
     uint m_force_shell_class : 1;
     uint m_has_hash_function : 1;
     uint m_has_equals_operator : 1;
     uint m_has_clone_operator :1;
     uint m_is_type_alias : 1;
-    uint m_reserved : 19;
+    uint m_reserved : 18;
     QString m_destructor_exception;
 
     const AbstractMetaClass *m_enclosing_class;
     AbstractMetaClass *m_base_class;
+    QList<AbstractMetaClass*> m_super_classes;
     const AbstractMetaClass *m_template_base_class;
     AbstractMetaFunctionList m_functions;
     AbstractMetaFieldList m_fields;

generator/setupgenerator.cpp

@@ -346,7 +346,7 @@ void SetupGenerator::generate()
           }
           shellCreator = ", " + setInstanceFunc + "<" + ShellGenerator::shellClassName(cls) + ">";
         } else {
-          shellCreator = ", NULL";
+          shellCreator = ", nullptr";
         }
         QString operatorCodes = getOperatorCodes(cls).join("|");
         if (operatorCodes.isEmpty()) {
@@ -431,7 +431,7 @@ QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QStrin
             s << "static void* polymorphichandler_" << handler
               << "(const void *ptr, const char **class_name)" << endl
               << "{" << endl
-              << "    Q_ASSERT(ptr != 0);" << endl
+              << "    Q_ASSERT(ptr != nullptr);" << endl
               << "    " << cls->qualifiedCppName() << " *object = ("
               << cls->qualifiedCppName() << " *)ptr;" << endl;
           }
@@ -456,7 +456,7 @@ QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QStrin
 
     // Close the function if it has been opened
     if (!first) {
-      s << "    return NULL;" << endl
+      s << "    return nullptr;" << endl
         << "}" << endl;
     }
   }

generator/shellheadergenerator.cpp

@@ -150,24 +150,24 @@ void ShellHeaderGenerator::write(QTextStream &s, const AbstractMetaClass *meta_c
           s << ", ";
         s << args.at(i)->argumentName();
       }
-      s << "),_wrapper(NULL) {";
+      s << "),_wrapper(nullptr) {";
       writeInjectedCode(s, meta_class, TypeSystem::PyInheritShellConstructorCode, true);
       s << "};" << endl;
     }
     s << endl;
-    s << "   ~" << shellClassName(meta_class) << "();" << endl;
+    const AbstractMetaClass* c = meta_class;
+    s << "   ~" << shellClassName(meta_class) << "()" << (meta_class->hasVirtualDestructor() ? " override" : "") << ";" << endl;
     s << endl;
 
     foreach(AbstractMetaFunction* fun, virtualsForShell) {
-      s << "virtual ";
       writeFunctionSignature(s, fun, 0, QString(),
         Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
-      s << ";" << endl;
+      s << " override;" << endl;
     }
     s << endl;
     if (meta_class->isQObject()) {
-      s << "  const QMetaObject* metaObject() const;" << endl;
-      s << "  int qt_metacall(QMetaObject::Call call, int id, void** args);" << endl;
+      s << "  const QMetaObject* metaObject() const override;" << endl;
+      s << "  int qt_metacall(QMetaObject::Call call, int id, void** args) override;" << endl;
     }
     writeInjectedCode(s, meta_class, TypeSystem::PyShellDeclaration);
     writeInjectedCode(s, meta_class, TypeSystem::PyInheritShellDeclaration, true);

generator/shellimplgenerator.cpp

@@ -155,7 +155,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
           writeTypeInfo(s, fun->type(), typeOptions);
           s << " returnValue{};" << endl;
         }
-        s << "      void* args[" << QString::number(args.size() + 1) << "] = {NULL";
+        s << "      void* args[" << QString::number(args.size() + 1) << "] = {nullptr";
         for (int i = 0; i < args.size(); ++i) {
           s << ", (void*)&" << args.at(i)->indexedName();
         }
@@ -164,9 +164,9 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
         s << "      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);" << endl;
         if (hasReturnValue) {
           s << "      if (result) {" << endl;
-          s << "        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);" << endl;
+          s << "        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);" << endl;
           s << "        if (args[0]!=&returnValue) {" << endl;
-          s << "          if (args[0]==NULL) {" << endl;
+          s << "          if (args[0]==nullptr) {" << endl;
           s << "            PythonQt::priv()->handleVirtualOverloadReturnError(\"" << fun->name() << "\", methodInfo, result);" << endl;
           s << "          } else {" << endl;
           s << "            returnValue = *((";
@@ -202,7 +202,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
           // return empty default object
           s << "return ";
           if (fun->type()->indirections()>0) {
-            s << "0;";
+            s << "nullptr;";
           } else {
             writeTypeInfo(s, fun->type(), typeOptions);
             s << "();";