MeVisLab · mrbean-bremen · Nov 17, 2023 · Nov 3, 2023 · Nov 6, 2023 · Nov 4, 2023
diff --git a/generator/abstractmetabuilder.cpp b/generator/abstractmetabuilder.cpp
@@ -409,6 +409,7 @@ bool AbstractMetaBuilder::build()
     file.close();
 
     Control control;
+    control.setSkipFunctionBody(true);
     Parser p(&control);
     pool __pool;
 
@@ -616,7 +617,15 @@ void AbstractMetaBuilder::addAbstractMetaClass(AbstractMetaClass *cls)
 
     cls->setOriginalAttributes(cls->attributes());
     if (cls->typeEntry()->isContainer()) {
-        m_templates << cls;
+        QString name = cls->typeEntry()->name();
+        if (cls->functions().size() || cls->baseClassNames().size()) {
+            if (!m_templates.contains(name)) {
+                m_templates[name] = cls;
+            }
+            else {
+                ReportHandler::warning(QString("Duplicate container type template '%1'").arg(name));
+            }
+        }
     } else {
         m_meta_classes << cls;
         if (cls->typeEntry()->designatedInterface()) {
@@ -1095,6 +1104,7 @@ AbstractMetaClass *AbstractMetaBuilder::traverseClass(ClassModelItem class_item)
         template_args.append(param_type);
     }
     meta_class->setTemplateArguments(template_args);
+    meta_class->setHasActualDeclaration(class_item->hasActualDeclaration());
 
     parseQ_Property(meta_class, class_item->propertyDeclarations());
 
@@ -1129,8 +1139,9 @@ AbstractMetaClass *AbstractMetaBuilder::traverseClass(ClassModelItem class_item)
 
     m_current_class = old_current_class;
 
-    // Set the default include file name
-    if (!type->include().isValid()) {
+    // Set the default include file name. In case we saw an template instance earlier,
+    // overwrite the include file when we see the actual declaration.
+    if (!type->include().isValid() || class_item->hasActualDeclaration()) {
         QFileInfo info(class_item->fileName());
         type->setInclude(Include(Include::IncludePath, info.fileName()));
     }
@@ -1242,7 +1253,7 @@ void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scope_item, AbstractM
                 }
             } else if (QPropertySpec *write =
                        meta_class->propertySpecForWrite(meta_function->name())) {
-                if (write->type() == meta_function->arguments().at(0)->type()->typeEntry()) {
+                if (meta_function->arguments().size() == 1 && write->type() == meta_function->arguments().at(0)->type()->typeEntry()) {
                     *meta_function += AbstractMetaAttributes::PropertyWriter;
                     meta_function->setPropertySpec(write);
 //                     printf("%s is writer for %s\n",
@@ -1336,13 +1347,7 @@ bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *meta_class)
             TypeParser::Info info = TypeParser::parse(complete_name);
             QString base_name = info.qualified_name.join("::");
 
-            AbstractMetaClass *templ = 0;
-            for (AbstractMetaClass *c :  m_templates) {
-                if (c->typeEntry()->name() == base_name) {
-                    templ = c;
-                    break;
-                }
-            }
+            AbstractMetaClass *templ = m_templates.value(base_name);
 
             if (templ == 0)
                 templ = m_meta_classes.findClass(base_name);
@@ -1486,6 +1491,12 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
       return 0;
     }
 
+    // Also filter out functions with template parameters in classes without template arguments
+    // (we don't support templated classes directly, but derived classes might derive from template instantiations)
+    if (function_item->templateParameters().size() && m_current_class->templateArguments().empty()) {
+      return 0;
+    }
+
     if (function_item->isAuto()) {
         /*TODO: it might work just to output 'auto', but this would require
          * understanding what AbstractMetabuild::translateType() does and
@@ -1593,6 +1604,11 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
             meta_function->setFunctionType(AbstractMetaFunction::SlotFunction);
     }
 
+    if (function_item->isDeleted()) {
+      meta_function->setInvalid(true);
+      return meta_function;
+    }
+
     ArgumentList arguments = function_item->arguments();
     AbstractMetaArgumentList meta_arguments;
 
@@ -1696,7 +1712,7 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
 
     }
 
-    if (typei.isFunctionPointer()) {
+    if (typei.isFunctionPointer() || typei.isRvalueReference()) { // function pointers or r-value references are not supported
         *ok = false;
         return 0;
     }
@@ -2485,55 +2501,112 @@ void AbstractMetaBuilder::dumpLog()
 
 AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted() const
 {
-    AbstractMetaClassList res;
-
-    AbstractMetaClassList classes = m_meta_classes;
-    classes.sort();
-
-    QSet<AbstractMetaClass*> noDependency;
-    QHash<AbstractMetaClass*, QSet<AbstractMetaClass* >* > hash;
-    for (AbstractMetaClass *cls :  classes) {
-        QSet<AbstractMetaClass* > *depends = new QSet<AbstractMetaClass* >();
+    /* This function is the standard topological sort of a Directed Acyclic
+     * Graph (a DAG).  It outputs a partially ordered list of the nodes in the
+     * graph such that a node is output after all of its children.
+     *
+     * In the previous implementation it seemed to account for around 68-69% of
+     * the entire run time of pythonqt_generator however this might be an
+     * artefact of the profiling technique used as these changes make not
+     * significant difference to the run time of the generator.
+     *
+     * However the previous implementation also leaked memory and  modified a
+     * QHash while iterating over it with a QHashIterator; a potentially fatal
+     * "use after free".
+     *
+     * This version is somewhat like the python equivalent using list
+     * comprehensions.
+     */
+
+    /* Build a hash list of QSet<class> for each class.  'class' is represented
+     * by a pointer to the AbstractMetaClass from m_meta_classes.
+     */
+    ReportHandler::debugSparse(QString("TSORT: %1 meta classes")
+            .arg(m_meta_classes.count()));
+    QHash<AbstractMetaClass*, QSet<AbstractMetaClass*>> classes;
+    classes.reserve(m_meta_classes.count());
+
+    for (auto cls : m_meta_classes) {
+        /* Add the baseClass and the interfaces the class uses.  The latter
+         * are stored in an AbstractMetaClassList which is uses a QList, so:
+         */
+        auto entry(classes.insert(cls,
+#           if QT_VERSION < QT_VERSION_CHECK(5,14,0)
+                QSet<AbstractMetaClass*>::fromList(cls->interfaces())
+#           else
+                QSet<AbstractMetaClass*>(cls->interfaces().cbegin(),
+                        cls->interfaces().cend())
+#           endif
+        ));
 
         if (cls->baseClass())
-            depends->insert(cls->baseClass());
-
-        for (AbstractMetaClass *interface :  cls->interfaces()) {
-            AbstractMetaClass *impl = interface->primaryInterfaceImplementor();
-            if (impl == cls)
-                continue;
-            depends->insert(impl);
-        }
-
-        if (depends->empty()) {
-            noDependency.insert(cls);
-        } else {
-            hash.insert(cls, depends);
-        }
-    }
-
-    while (!noDependency.empty()) {
-        for (AbstractMetaClass *cls :  noDependency.values()) {
-            if(!cls->isInterface())
-                res.append(cls);
-            noDependency.remove(cls);
-            QHashIterator<AbstractMetaClass*, QSet<AbstractMetaClass* >* > i(hash);
-            while (i.hasNext()) {
-                i.next();
-                i.value()->remove(cls);
-                if (i.value()->empty()) {
-                    AbstractMetaClass *key = i.key();
-                    noDependency.insert(key);
-                    hash.remove(key);
-                    delete(i.value());
-                }
-            }
-        }
-    }
-
-    if (!noDependency.empty() || !hash.empty()) {
-        qWarning("dependency graph was cyclic.");
-    }
+            entry.value().insert(cls->baseClass());
+        entry.value().remove(cls); // may come from interfaces
+    }
+
+    /* This and the qFatals below are fatal internal errors in the code of
+     * pythonqt_generator.
+     */
+    if (m_meta_classes.count() != classes.count())
+        qFatal("TOPO SORT: duplicate meta classes (%lld != %lld)",
+                static_cast<long long>(m_meta_classes.count()),
+                static_cast<long long>(classes.count()));
+
+    /* Loop: output all the classes with no remaining dependencies to the
+     * result and then also remove those now output classes from the remaining
+     * classes in the hash table.
+     */
+    AbstractMetaClassList result;
+    result.reserve(classes.count());
+    QSet<AbstractMetaClass *> handled;
+    handled.reserve(classes.count());
+    int interfaceClasses(0), depthFromLeaf(0);
+
+    while (!classes.empty()) {
+        handled.clear();
+        int iFCount(0);
+
+        /* Output classes where all children have already been output (initially
+         * the leaf nodes):
+         */
+        for (auto i(classes.cbegin()); i != classes.cend(); ++i)
+            if (i.value().empty())
+                handled.insert(i.key());
 
-    return res;
+        /* Something must have been done; if not this is not a DAG because
+         * there is a cycle.
+         */
+        if (handled.empty())
+            qFatal("TOPOSORT: %lld cyclic meta classes @depth %d.",
+                    static_cast<long long>(classes.count()), depthFromLeaf);
+
+        /* Remove all 'handled' from the hash table. */
+        for (auto cls : handled)
+            if (!classes.remove(cls))
+                qFatal("TOPO SORT: class remove failed @depth %d.",
+                        depthFromLeaf);
+
+        /* Then remove the 'handled' set from the classes values: */
+        for (QSet<AbstractMetaClass*> &set : classes)
+            set -= handled;
+
+        /* Output only those handled classes there are not interfaces: */
+        for (auto cls : handled) {
+            if (!cls->isInterface())
+                result.append(cls);
+            else
+                ++iFCount;
+        }
+
+        ReportHandler::debugSparse(
+                QString("TSORT: depth %1: %2 classes (%3 interface)")
+                .arg(depthFromLeaf).arg(handled.count()).arg(iFCount));
+        interfaceClasses += iFCount;
+        ++depthFromLeaf;
+    }
+
+    ReportHandler::debugSparse(QString(
+                "TSORT: %1 result classes, %2 interface classes)")
+                .arg(result.count()).arg(interfaceClasses));
+    return result;
 }
diff --git a/generator/abstractmetabuilder.h b/generator/abstractmetabuilder.h
@@ -150,7 +150,7 @@ class AbstractMetaBuilder
     QString m_file_name;
 
     AbstractMetaClassList m_meta_classes;
-    AbstractMetaClassList m_templates;
+    QHash<QString,AbstractMetaClass*> m_templates;
     FileModelItem m_dom;
 
     QSet<const TypeEntry *> m_used_types;

diff --git a/generator/abstractmetalang.h b/generator/abstractmetalang.h
@@ -675,6 +675,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
           m_has_equals_operator(false),
           m_has_clone_operator(false),
           m_is_type_alias(false),
+          m_has_actual_declaration(false),
           m_qDebug_stream_function(0)
     {
     }
@@ -796,6 +797,9 @@ class AbstractMetaClass : public AbstractMetaAttributes
     void setHasCloneOperator(bool on) { m_has_clone_operator = on; }
     bool hasCloneOperator() const { return m_has_clone_operator; }
 
+    void setHasActualDeclaration(bool on) { m_has_actual_declaration = on; }
+    bool hasActualDeclaration() const { return m_has_actual_declaration; }
+
     QString getDefaultNonZeroFunction() const;
 
     void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
@@ -856,7 +860,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
     uint m_has_equals_operator : 1;
     uint m_has_clone_operator :1;
     uint m_is_type_alias : 1;
-    uint m_reserved : 18;
+    uint m_has_actual_declaration : 1;
+    uint m_reserved : 17;
     QString m_destructor_exception;
 
     const AbstractMetaClass *m_enclosing_class{};

diff --git a/generator/parser/ast.h b/generator/parser/ast.h
@@ -512,6 +512,8 @@ struct InitializerAST: public AST
 
   InitializerClauseAST *initializer_clause{};
   ExpressionAST *expression{};
+  bool isDefault{};
+  bool isDeleted{};
 };
 
 struct InitializerClauseAST: public AST

diff --git a/generator/parser/binder.cpp b/generator/parser/binder.cpp
@@ -282,7 +282,9 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
       fun->setAccessPolicy(_M_current_access);
       fun->setFunctionType(_M_current_function_type);
       fun->setName(name_cc.name());
-      fun->setAbstract(init_declarator->initializer != 0);
+      InitializerAST* initializer = init_declarator->initializer;
+      fun->setDeleted(initializer && initializer->isDeleted);
+      fun->setAbstract(initializer && !initializer->isDefault && !initializer->isDeleted);  // must be "= 0"
       fun->setConstant(declarator->fun_cv != 0);
       fun->setException(exceptionSpecToString(declarator->exception_spec));
 
@@ -727,6 +729,7 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
   name_cc.run(node->name->unqualified_name);
   _M_context.append(name_cc.name());
   visitNodes(this, node->member_specs);
+  _M_current_class->setHasActualDeclaration(node->member_specs);
   _M_context.removeLast();
 
   changeCurrentClass(old);

diff --git a/generator/parser/codemodel.cpp b/generator/parser/codemodel.cpp
@@ -731,6 +731,16 @@ void _FunctionModelItem::setAbstract(bool isAbstract)
   _M.isAbstract = isAbstract;
 }
 
+bool _FunctionModelItem::isDeleted() const
+{
+  return _M.isDeleted;
+}
+
+void _FunctionModelItem::setDeleted(bool isDeleted)
+{
+  _M.isDeleted = isDeleted;
+}
+
 // Qt
 bool _FunctionModelItem::isInvokable() const
 {

diff --git a/generator/parser/codemodel.h b/generator/parser/codemodel.h
@@ -366,6 +366,10 @@ class _ClassModelItem: public _ScopeModelItem
   void addPropertyDeclaration(const QString &propertyDeclaration);
   QStringList propertyDeclarations() const { return _M_propertyDeclarations; }
 
+  void setHasActualDeclaration(bool flag) { _M_hasActualDeclaration = flag; }
+  bool hasActualDeclaration() const { return _M_hasActualDeclaration; }
+
+
 protected:
   _ClassModelItem(CodeModel *model, int kind = __node_kind)
     : _ScopeModelItem(model, kind), _M_classType(CodeModel::Class) {}
@@ -377,6 +381,8 @@ class _ClassModelItem: public _ScopeModelItem
 
   QStringList _M_propertyDeclarations;
 
+  bool _M_hasActualDeclaration{};
+
 private:
   _ClassModelItem(const _ClassModelItem &other);
   void operator = (const _ClassModelItem &other);
@@ -566,6 +572,9 @@ class _FunctionModelItem: public _MemberModelItem
   bool isAbstract() const;
   void setAbstract(bool isAbstract);
 
+  bool isDeleted() const;
+  void setDeleted(bool isDeleted);
+
   bool isVariadics() const;
   void setVariadics(bool isVariadics);
 
@@ -589,6 +598,7 @@ class _FunctionModelItem: public _MemberModelItem
       uint isVirtual: 1;
       uint isInline: 1;
       uint isAbstract: 1;
+      uint isDeleted: 1;
       uint isExplicit: 1;
       uint isVariadics: 1;
       uint isInvokable : 1; // Qt