Change pointers to QShared pointers to decrease memory leaks

Author: YuriUfimtsev

generator/abstractmetabuilder.cpp

@@ -1758,7 +1758,7 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
         if (container_type == ContainerTypeEntry::StringListContainer) {
             TypeInfo info;
             info.setQualifiedName(QStringList() << "QString");
-            AbstractMetaType *targ_type = translateType(info, ok);
+            AbstractMetaType::shared_pointer targ_type(translateType(info, ok));
 
             Q_ASSERT(*ok);
             Q_ASSERT(targ_type);
@@ -1776,7 +1776,7 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
                 info.setFunctionPointer(false);
                 info.setQualifiedName(ta.instantiationName().split("::"));
 
-                AbstractMetaType *targ_type = translateType(info, ok);
+                AbstractMetaType::shared_pointer targ_type (translateType(info, ok));
                 if (!(*ok)) {
                     delete meta_type;
                     return 0;
@@ -1974,9 +1974,9 @@ AbstractMetaType *AbstractMetaBuilder::inheritTemplateType(const QList<AbstractM
     }
 
     if (returned->hasInstantiations()) {
-        QList<AbstractMetaType *> instantiations = returned->instantiations();
+        auto instantiations = returned->instantiations();
         for (int i=0; i<instantiations.count(); ++i) {
-            instantiations[i] = inheritTemplateType(template_types, instantiations.at(i), ok);
+            instantiations[i] = AbstractMetaType::shared_pointer(inheritTemplateType(template_types, instantiations[i].data(), ok));
             if (ok != 0 && !(*ok))
                 return 0;
         }

generator/abstractmetalang.cpp

@@ -82,7 +82,7 @@ QString AbstractMetaType::cppSignature() const
     s += typeEntry()->qualifiedCppName();
 
     if (hasInstantiationInCpp()) {
-        QList<AbstractMetaType *> types = instantiations();
+        auto &types = instantiations();
         s += "<";
         for (int i=0; i<types.count(); ++i) {
             if (i > 0)
@@ -1633,9 +1633,9 @@ static void add_extra_include_for_type(AbstractMetaClass *meta_class, const Abst
     }
 
     if (type->hasInstantiations()) {
-        QList<AbstractMetaType *> instantiations = type->instantiations();
-        foreach (AbstractMetaType *instantiation, instantiations)
-            add_extra_include_for_type(meta_class, instantiation);
+        auto &instantiations = type->instantiations();
+        for(auto &&instantiation: instantiations)
+            add_extra_include_for_type(meta_class, instantiation.data());
     }
 }
 
@@ -1927,7 +1927,7 @@ QString AbstractMetaType::minimalSignature() const
         minimalSignature += "const ";
     minimalSignature += typeEntry()->qualifiedCppName();
     if (hasInstantiations()) {
-        QList<AbstractMetaType *> instantiations = this->instantiations();
+        auto &instantiations = this->instantiations();
         minimalSignature += "<";
         for (int i=0;i<instantiations.size();++i) {
             if (i > 0)

generator/abstractmetalang.h

@@ -49,7 +49,7 @@
 #include <QSet>
 #include <QStringList>
 #include <QTextStream>
-
+#include <QSharedPointer>
 
 class AbstractMeta;
 class AbstractMetaClass;
@@ -162,6 +162,7 @@ class AbstractMetaAttributes
 class AbstractMetaType
 {
 public:
+    typedef QSharedPointer<AbstractMetaType> shared_pointer;
     enum TypeUsagePattern {
         InvalidPattern,
         PrimitivePattern,
@@ -200,9 +201,9 @@ class AbstractMetaType
 
     // true when use pattern is container
     bool hasInstantiations() const { return !m_instantiations.isEmpty(); }
-    void addInstantiation(AbstractMetaType *inst) { m_instantiations << inst; }
-    void setInstantiations(const QList<AbstractMetaType *> &insts) { m_instantiations = insts; }
-    QList<AbstractMetaType *> instantiations() const { return m_instantiations; }
+    void addInstantiation(AbstractMetaType::shared_pointer inst) { m_instantiations << inst; }
+    void setInstantiations(const QList<AbstractMetaType::shared_pointer> &insts) { m_instantiations = insts; }
+    const QList<AbstractMetaType::shared_pointer> &instantiations() const { return m_instantiations; }
     void setInstantiationInCpp(bool incpp) { m_cpp_instantiation = incpp; }
     bool hasInstantiationInCpp() const { return hasInstantiations() && m_cpp_instantiation; }
 
@@ -293,7 +294,7 @@ class AbstractMetaType
 
 private:
     const TypeEntry *m_type_entry{};
-    QList <AbstractMetaType *> m_instantiations;
+    QList <AbstractMetaType::shared_pointer> m_instantiations;
     QString m_package;
     QString m_original_type_description;
 

generator/parser/codemodel.h

@@ -52,6 +52,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QVector>
 #include <QtCore/QSet>
+#include <QSharedPointer>
 
 #define DECLARE_MODEL_NODE(k) \
     enum { __node_kind = Kind_##k }; \

generator/parser/codemodel_fwd.h

@@ -45,6 +45,7 @@
 
 #include <codemodel_pointer.h>
 #include <QtCore/QList>
+#include <QSharedPointer>
 
 // forward declarations
 class CodeModel;
@@ -64,20 +65,20 @@ class _VariableModelItem;
 class _MemberModelItem;
 struct TypeInfo;
 
-typedef CodeModelPointer<_ArgumentModelItem> ArgumentModelItem;
-typedef CodeModelPointer<_ClassModelItem> ClassModelItem;
-typedef CodeModelPointer<_CodeModelItem> CodeModelItem;
-typedef CodeModelPointer<_EnumModelItem> EnumModelItem;
-typedef CodeModelPointer<_EnumeratorModelItem> EnumeratorModelItem;
-typedef CodeModelPointer<_FileModelItem> FileModelItem;
-typedef CodeModelPointer<_FunctionDefinitionModelItem> FunctionDefinitionModelItem;
-typedef CodeModelPointer<_FunctionModelItem> FunctionModelItem;
-typedef CodeModelPointer<_NamespaceModelItem> NamespaceModelItem;
-typedef CodeModelPointer<_ScopeModelItem> ScopeModelItem;
-typedef CodeModelPointer<_TemplateParameterModelItem> TemplateParameterModelItem;
-typedef CodeModelPointer<_TypeAliasModelItem> TypeAliasModelItem;
-typedef CodeModelPointer<_VariableModelItem> VariableModelItem;
-typedef CodeModelPointer<_MemberModelItem> MemberModelItem;
+typedef QSharedPointer<_ArgumentModelItem> ArgumentModelItem;
+typedef QSharedPointer<_ClassModelItem> ClassModelItem;
+typedef QSharedPointer<_CodeModelItem> CodeModelItem;
+typedef QSharedPointer<_EnumModelItem> EnumModelItem;
+typedef QSharedPointer<_EnumeratorModelItem> EnumeratorModelItem;
+typedef QSharedPointer<_FileModelItem> FileModelItem;
+typedef QSharedPointer<_FunctionDefinitionModelItem> FunctionDefinitionModelItem;
+typedef QSharedPointer<_FunctionModelItem> FunctionModelItem;
+typedef QSharedPointer<_NamespaceModelItem> NamespaceModelItem;
+typedef QSharedPointer<_ScopeModelItem> ScopeModelItem;
+typedef QSharedPointer<_TemplateParameterModelItem> TemplateParameterModelItem;
+typedef QSharedPointer<_TypeAliasModelItem> TypeAliasModelItem;
+typedef QSharedPointer<_VariableModelItem> VariableModelItem;
+typedef QSharedPointer<_MemberModelItem> MemberModelItem;
 
 typedef QList<ArgumentModelItem> ArgumentList;
 typedef QList<ClassModelItem> ClassList;

generator/setupgenerator.cpp

@@ -178,7 +178,7 @@ static QSet<QString> _builtinListTypes = QSet<QString>() << "QByteArray"
 
 static void addListRegistration(AbstractMetaType* type, QSet<QString>& output) {
   if (type->instantiations().size() > 0) {
-    QList<AbstractMetaType *> args = type->instantiations();
+    QList<AbstractMetaType::shared_pointer> args = type->instantiations();
 
     /*
     QString debugStr;
@@ -271,12 +271,12 @@ void SetupGenerator::generate()
 
       QSet<QString> listRegistration;
       QSet<QString> snips;
-      for (const AbstractMetaClass *cls :  list) {
-        Q_FOREACH(const AbstractMetaFunction* func, cls->functions()) {
+      for (auto cls: list) {
+          for(auto &&func: cls->functions()) {
           if (func->type() && func->type()->isContainer()) {
             addListRegistration(func->type(), listRegistration);
           }
-          Q_FOREACH(const AbstractMetaArgument* arg, func->arguments()) {
+          for(auto &&arg: func->arguments()) {
             if (arg->type() && arg->type()->isContainer()) {
               addListRegistration(arg->type(), listRegistration);
             }
@@ -365,7 +365,7 @@ void SetupGenerator::generate()
       QStringList list(listRegistration.begin(), listRegistration.end());
 #endif
       list.sort();
-      Q_FOREACH(QString name, list) {
+      for(auto &&name: list) {
         if (name.contains("Ssl")) {
           s << "#ifndef QT_NO_SSL" << endl;
         }

generator/shellgenerator.cpp

@@ -96,13 +96,13 @@ void ShellGenerator::writeTypeInfo(QTextStream &s, const AbstractMetaType *type,
         && (!te->isContainer() 
             || (static_cast<const ContainerTypeEntry *>(te))->type() != ContainerTypeEntry::StringListContainer)) {
         s << '<';
-        QList<AbstractMetaType *> args = type->instantiations();
+        auto &args = type->instantiations();
         bool nested_template = false;
         for (int i=0; i<args.size(); ++i) {
             if (i != 0)
                 s << ", ";
             nested_template |= args.at(i)->isContainer();
-            writeTypeInfo(s, args.at(i));
+            writeTypeInfo(s, args.at(i).data());
         }
         if (nested_template)
             s << ' ';