Refactor: change casts and remove toItem() to make it compatible with QSharedPointer

Author: YuriUfimtsev

generator/abstractmetabuilder.cpp

@@ -442,14 +442,14 @@ bool AbstractMetaBuilder::build()
     Binder binder(&model, p.location());
     m_dom = binder.run(ast);
 
-    pushScope(model_dynamic_cast<ScopeModelItem>(m_dom));
+    pushScope(m_dom.dynamicCast<_ScopeModelItem>());
 
     QHash<QString, ClassModelItem> typeMap = m_dom->classMap();
 
 
     // fix up QObject's in the type system..
     TypeDatabase *types = TypeDatabase::instance();
-    fixQObjectForScope(types, model_dynamic_cast<NamespaceModelItem>(m_dom));
+    fixQObjectForScope(types, m_dom.dynamicCast<_NamespaceModelItem>());
 
 
     // Start the generation...
@@ -707,8 +707,8 @@ AbstractMetaClass *AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
                                .arg(meta_class->package())
                                .arg(namespace_item->name()));
 
-    traverseEnums(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class, namespace_item->qEnumDeclarations());
-    traverseFunctions(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class);
+    traverseEnums(namespace_item.dynamicCast<_ScopeModelItem>(), meta_class, namespace_item->qEnumDeclarations());
+    traverseFunctions(namespace_item.dynamicCast<_ScopeModelItem>(), meta_class);
 //     traverseClasses(model_dynamic_cast<ScopeModelItem>(namespace_item));
 
     // collect all include files (since namespace items might come from different files)
@@ -721,7 +721,7 @@ AbstractMetaClass *AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
     }
     // (should we do this for typeAliases and inner namespaces too?)
 
-    pushScope(model_dynamic_cast<ScopeModelItem>(namespace_item));
+    pushScope(namespace_item.dynamicCast<_ScopeModelItem>());
     m_namespace_prefix = currentScope()->qualifiedName().join("::");
 
 
@@ -950,9 +950,9 @@ AbstractMetaClass *AbstractMetaBuilder::traverseClass(ClassModelItem class_item)
     meta_class->setTemplateArguments(template_args);
     meta_class->setHasActualDeclaration(class_item->hasActualDeclaration());
 
-    traverseFunctions(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
-    traverseEnums(model_dynamic_cast<ScopeModelItem>(class_item), meta_class, class_item->qEnumDeclarations());
-    traverseFields(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
+    traverseFunctions(class_item.dynamicCast<_ScopeModelItem>(), meta_class);
+    traverseEnums(class_item.dynamicCast<_ScopeModelItem>(), meta_class, class_item->qEnumDeclarations());
+    traverseFields(class_item.dynamicCast<_ScopeModelItem>(), meta_class);
 
     parseQ_Property(meta_class, class_item->propertyDeclarations());
 
@@ -1023,7 +1023,7 @@ AbstractMetaField *AbstractMetaBuilder::traverseField(VariableModelItem field, c
         ReportHandler::warning(QString("skipping field '%1::%2' with unmatched type '%3'")
                                .arg(m_current_class->name())
                                .arg(field_name)
-                               .arg(TypeInfo::resolveType(field_type, currentScope()->toItem()).qualifiedName().join("::")));
+                               .arg(TypeInfo::resolveType(field_type, currentScope()).qualifiedName().join("::")));
         delete meta_field;
         return 0;
     }
@@ -1596,7 +1596,7 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
         // seemed non-trivial
         int i = m_scopes.size() - 1;
         while (i >= 0) {
-            typei = TypeInfo::resolveType(_typei, m_scopes.at(i--)->toItem());
+            typei = TypeInfo::resolveType(_typei, m_scopes.at(i--));
             if (typei.qualifiedName().join("::") != _typei.qualifiedName().join("::"))
                 break;
         }
@@ -1909,7 +1909,7 @@ bool AbstractMetaBuilder::isQObject(const QString &qualified_name)
 
     if (!class_item) {
       QStringList names = qualified_name.split(QLatin1String("::"));
-      NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(m_dom);
+      NamespaceModelItem ns = m_dom.dynamicCast<_NamespaceModelItem>();
       for (int i=0; i<names.size() - 1 && ns; ++i)
           ns = ns->namespaceMap().value(names.at(i));
       if (ns && names.size() >= 2)
@@ -1934,7 +1934,7 @@ bool AbstractMetaBuilder::isQObject(const QString &qualified_name)
 
 bool AbstractMetaBuilder::isEnum(const QStringList &qualified_name)
 {
-    CodeModelItem item = m_dom->model()->findItem(qualified_name, m_dom->toItem());
+    CodeModelItem item = m_dom->model()->findItem(qualified_name, m_dom);
     return item && item->kind() == _EnumModelItem::__node_kind;
 }
 

generator/parser/binder.cpp

@@ -82,7 +82,7 @@ FileModelItem Binder::run(AST *node)
   _M_current_access = CodeModel::Public;
 
   _M_current_file = model()->create<FileModelItem>();
-  updateItemPosition (_M_current_file->toItem(), node);
+  updateItemPosition (_M_current_file, node);
   visit(node);
   FileModelItem result = _M_current_file;
 
@@ -94,11 +94,11 @@ FileModelItem Binder::run(AST *node)
 ScopeModelItem Binder::currentScope() const
 {
   if (_M_current_class)
-    return model_static_cast<ScopeModelItem>(_M_current_class);
+    return _M_current_class.staticCast<_ScopeModelItem>();
   else if (_M_current_namespace)
-    return model_static_cast<ScopeModelItem>(_M_current_namespace);
+    return _M_current_namespace.staticCast<_ScopeModelItem>();
 
-  return model_static_cast<ScopeModelItem>(_M_current_file);
+  return _M_current_file.staticCast<_ScopeModelItem>();
 }
 
 TemplateParameterList Binder::changeTemplateParameters(TemplateParameterList templateParameters)
@@ -278,7 +278,7 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
       name_cc.run(id->unqualified_name);
 
       FunctionModelItem fun = model()->create<FunctionModelItem>();
-      updateItemPosition (fun->toItem(), node);
+      updateItemPosition (fun, node);
       fun->setAccessPolicy(_M_current_access);
       fun->setFunctionType(_M_current_function_type);
       fun->setName(name_cc.name());
@@ -289,7 +289,7 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
       fun->setException(exceptionSpecToString(declarator->exception_spec));
 
       fun->setTemplateParameters(_M_current_template_parameters);
-      applyStorageSpecifiers(node->storage_specifiers, model_static_cast<MemberModelItem>(fun));
+      applyStorageSpecifiers(node->storage_specifiers, fun.staticCast<_MemberModelItem>());
       applyFunctionSpecifiers(node->function_specifiers, fun);
 
       if (const ListNode<InitDeclaratorAST*> *it = node->init_declarators)
@@ -335,7 +335,7 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
   else
     {
       VariableModelItem var = model()->create<VariableModelItem>();
-      updateItemPosition (var->toItem(), node);
+      updateItemPosition (var, node);
       var->setTemplateParameters(_M_current_template_parameters);
       var->setAccessPolicy(_M_current_access);
       name_cc.run(id->unqualified_name);
@@ -353,7 +353,7 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
         }
 
       var->setType(qualifyType(typeInfo, _M_context));
-      applyStorageSpecifiers(node->storage_specifiers, model_static_cast<MemberModelItem>(var));
+      applyStorageSpecifiers(node->storage_specifiers, var.staticCast<_MemberModelItem>());
 
       var->setScope(symbolScope->qualifiedName());
       symbolScope->addVariable(var);
@@ -372,7 +372,7 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
       // check if this function declaration is a "friend" function with implementation body.
       // In this case we modify the scope, and remove the "friend" flag later on.
       friendWithDefinition = true;
-      scope = model_static_cast<ScopeModelItem>(_M_current_file);
+      scope = _M_current_file.staticCast<_ScopeModelItem>();
     }
 
   InitDeclaratorAST *init_declarator = node->init_declarator;
@@ -433,7 +433,7 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
   FunctionDefinitionModelItem
     old = changeCurrentFunction(_M_model->create<FunctionDefinitionModelItem>());
   _M_current_function->setScope(functionScope->qualifiedName());
-  updateItemPosition (_M_current_function->toItem(), node);
+  updateItemPosition (_M_current_function, node);
 
   Q_ASSERT(declarator->id->unqualified_name != 0);
   name_cc.run(declarator->id->unqualified_name);
@@ -451,12 +451,12 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
   _M_current_function->setException(exceptionSpecToString(declarator->exception_spec));
 
   applyStorageSpecifiers(node->storage_specifiers,
-                          model_static_cast<MemberModelItem>(_M_current_function));
+                          _M_current_function.staticCast<_MemberModelItem>());
   applyFunctionSpecifiers(node->function_specifiers,
-                          model_static_cast<FunctionModelItem>(_M_current_function));
+                          _M_current_function.staticCast<_FunctionModelItem>());
   if (node->init_declarator->declarator && node->init_declarator->declarator->_override) {
     //std::cout << unqualified_name.toLatin1().constData() << std::endl;
-    model_static_cast<FunctionModelItem>(_M_current_function)->setVirtual(true);
+    _M_current_function.staticCast<_FunctionModelItem>()->setVirtual(true);
   }
 
   if (friendWithDefinition)
@@ -493,7 +493,7 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
 
   functionScope->addFunctionDefinition(_M_current_function);
 
-  FunctionModelItem prototype = model_static_cast<FunctionModelItem>(_M_current_function);
+  FunctionModelItem prototype = _M_current_function.staticCast<_FunctionModelItem>();
   FunctionModelItem declared = functionScope->declaredFunction(prototype);
 
   // try to find a function declaration for this definition..
@@ -506,7 +506,7 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
       applyFunctionSpecifiers(node->function_specifiers, declared);
       if (node->init_declarator->declarator && node->init_declarator->declarator->_override) {
         //std::cout << unqualified_name.toLatin1().constData() << std::endl;
-        model_static_cast<FunctionModelItem>(_M_current_function)->setVirtual(true);
+        _M_current_function.staticCast<_FunctionModelItem>()->setVirtual(true);
       }
 
       // fix the function type and the access policy
@@ -647,7 +647,7 @@ void Binder::visitTypedef(TypedefAST *node)
       ScopeModelItem typedefScope = finder.resolveScope(declarator->id, scope);
 
       TypeAliasModelItem typeAlias = model ()->create<TypeAliasModelItem> ();
-      updateItemPosition (typeAlias->toItem (), node);
+      updateItemPosition (typeAlias, node);
       typeAlias->setName (alias_name);
       typeAlias->setType (qualifyType (typeInfo, currentScope ()->qualifiedName ()));
       typeAlias->setScope (typedefScope->qualifiedName());
@@ -670,13 +670,12 @@ void Binder::visitNamespace(NamespaceAST *node)
 
       QStringList qualified_name = scope->qualifiedName();
       qualified_name += name;
-      NamespaceModelItem ns =
-        model_safe_cast<NamespaceModelItem>(_M_model->findItem(qualified_name,
-                                                                  _M_current_file->toItem()));
+      NamespaceModelItem ns = (_M_model->findItem(qualified_name,_M_current_file))
+              .dynamicCast<_NamespaceModelItem>();
       if (!ns)
         {
           ns = _M_model->create<NamespaceModelItem>();
-          updateItemPosition (ns->toItem(), node);
+          updateItemPosition (ns, node);
           ns->setName(name);
           ns->setScope(scope->qualifiedName());
         }
@@ -694,7 +693,7 @@ void Binder::visitNamespace(NamespaceAST *node)
 
       _M_context.removeLast();
 
-      if (NamespaceModelItem ns = model_static_cast<NamespaceModelItem>(scope))
+      if (NamespaceModelItem ns = scope.staticCast<_NamespaceModelItem>())
         {
           ns->addNamespace(_M_current_namespace);
         }
@@ -729,7 +728,7 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
   ScopeModelItem scope = currentScope();
 
   ClassModelItem old = changeCurrentClass(_M_model->create<ClassModelItem>());
-  updateItemPosition (_M_current_class->toItem(), node);
+  updateItemPosition (_M_current_class, node);
   _M_current_class->setName(class_cc.name());
 
   QStringList baseClasses = class_cc.baseClasses(); TypeInfo info;
@@ -809,7 +808,7 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
   _M_current_enum = model()->create<EnumModelItem>();
   _M_current_enum->setAccessPolicy(_M_current_access);
   _M_current_enum->setEnumClass(node->is_enum_class);
-  updateItemPosition (_M_current_enum->toItem(), node);
+  updateItemPosition (_M_current_enum, node);
   _M_current_enum->setName(name);
   _M_current_enum->setScope(enumScope->qualifiedName());
 
@@ -837,7 +836,7 @@ void Binder::visitEnumerator(EnumeratorAST *node)
 {
   Q_ASSERT(_M_current_enum.data() != 0);
   EnumeratorModelItem e = model()->create<EnumeratorModelItem>();
-  updateItemPosition (e->toItem(), node);
+  updateItemPosition (e, node);
   e->setName(decode_symbol(node->id)->as_string());
 
   if (ExpressionAST *expr = node->expression)
@@ -1013,9 +1012,9 @@ TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) c
         }
       else
         {
-          CodeModelItem scope = model ()->findItem (context, _M_current_file->toItem ());
+          CodeModelItem scope = model ()->findItem (context, _M_current_file);
 
-          if (ClassModelItem klass = model_dynamic_cast<ClassModelItem> (scope))
+          if (ClassModelItem klass = scope.dynamicCast<_ClassModelItem> ())
             {
               foreach (QString base, klass->baseClasses ())
                 {

generator/parser/codemodel.cpp

@@ -99,15 +99,15 @@ CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelIte
     // ### Extend to look for members etc too.
     const QString &name = qualifiedName.at(i);
 
-    if (NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(scope))
+    if (NamespaceModelItem ns = scope.dynamicCast<_NamespaceModelItem>())
       {
         if (NamespaceModelItem tmp_ns = ns->findNamespace(name)) {
           scope = tmp_ns;
           continue;
         }
       }
 
-    if (ScopeModelItem ss = model_dynamic_cast<ScopeModelItem>(scope))
+    if (ScopeModelItem ss = scope.dynamicCast<_ScopeModelItem>())
       {
         if (ClassModelItem cs = ss->findClass(name))
           {
@@ -116,12 +116,12 @@ CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelIte
         else if (EnumModelItem es = ss->findEnum(name))
           {
             if (i == qualifiedName.size () - 1)
-              return es->toItem();
+              return es;
           }
         else if (TypeAliasModelItem tp = ss->findTypeAlias(name))
           {
             if (i == qualifiedName.size () - 1)
-              return tp->toItem ();
+              return tp;
           }
         else
           {
@@ -169,7 +169,7 @@ TypeInfo TypeInfo::resolveType (TypeInfo const &__type, CodeModelItem __scope)
         otherType.setQualifiedName(__item->qualifiedName());
     }
 
-    if (TypeAliasModelItem __alias = model_dynamic_cast<TypeAliasModelItem> (__item))
+    if (TypeAliasModelItem __alias = __item.dynamicCast<_TypeAliasModelItem>())
         return resolveType (TypeInfo::combine (__alias->type (), otherType), __scope);
 
     return otherType;

generator/parser/codemodel.h

@@ -403,7 +403,7 @@ class _NamespaceModelItem: public _ScopeModelItem
 
   NamespaceModelItem findNamespace(const QString &name) const;
 
-  inline QHash<QString, NamespaceModelItem> namespaceMap() const { return _M_namespaces; };
+  inline QHash<QString, NamespaceModelItem> namespaceMap() const { return _M_namespaces; }
 
 protected:
   _NamespaceModelItem(CodeModel *model, int kind = __node_kind)

generator/parser/codemodel_finder.cpp

@@ -106,15 +106,15 @@ void CodeModelFinder::visitUnqualifiedName(UnqualifiedNameAST *node)
     {
       _M_current_scope = klass;
     }
-  else if (NamespaceModelItem parentNamespace = model_safe_cast<NamespaceModelItem>(_M_current_scope))
+  else if (NamespaceModelItem parentNamespace = _M_current_scope.dynamicCast<_NamespaceModelItem>())
     {
       NamespaceModelItem ns = parentNamespace->findNamespace(id);
-      _M_current_scope = model_static_cast<ScopeModelItem>(ns);
+      _M_current_scope = ns.staticCast<_ScopeModelItem>();
     }
-  else if (FileModelItem file = model_safe_cast<FileModelItem>(_M_current_scope))
+  else if (FileModelItem file = _M_current_scope.dynamicCast<_FileModelItem>())
     {
       NamespaceModelItem ns = file->findNamespace(id);
-      _M_current_scope = model_static_cast<ScopeModelItem>(ns);
+      _M_current_scope = ns.staticCast<_ScopeModelItem>();
     }
   }
 

generator/parser/name_compiler.cpp

@@ -138,7 +138,7 @@ void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node)
           q = tp.qualifiedName ();
 #endif
 
-          if (CodeModelItem item = _M_binder->model ()->findItem (q, _M_binder->currentScope ()->toItem ()))
+          if (CodeModelItem item = _M_binder->model ()->findItem (q, _M_binder->currentScope ()))
             {
               if (item->name () == q.last ())
                 q = item->qualifiedName ();