Change class AbstractMetaClassList to be a typedef for a QList

Inheriting from standard containers is not recommended.
Move the find() functions to static functions of AbstractMetaClass.

Change-Id: Iaa8db0a4cdf9e2fd70d046558313d6ba7ff7497a
Reviewed-by: Christian Tismer <tismer@stackless.com>

42 files changed, 208 insertions, 203 deletions

diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index d028c9392..358f995b1 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -180,7 +180,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
             QString name = signature.trimmed();
             name.truncate(name.indexOf(QLatin1Char('(')));
 
-            AbstractMetaClass* clazz = m_metaClasses.findClass(centry->qualifiedCppName());
+            AbstractMetaClass *clazz = AbstractMetaClass::findClass(m_metaClasses, centry->qualifiedCppName());
             if (!clazz)
                 continue;
 
@@ -215,7 +215,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(ArgumentModelItem
     AbstractMetaType* type = translateType(argument->type(), &ok);
     if (ok && type && type->typeEntry() && type->typeEntry()->isComplex()) {
         const TypeEntry *entry = type->typeEntry();
-        returned = m_metaClasses.findClass(entry->name());
+        returned = AbstractMetaClass::findClass(m_metaClasses, entry->name());
     }
     delete type;
     return returned;
@@ -313,7 +313,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(FunctionModelItem item
             && (retType->isValue() || retType->isObject())
             && retType != baseoperandClass->typeEntry()
             && retType == otherArgClass->typeEntry()) {
-            baseoperandClass = m_metaClasses.findClass(retType);
+            baseoperandClass = AbstractMetaClass::findClass(m_metaClasses, retType);
             firstArgumentIsSelf = false;
         }
         delete type;
@@ -594,7 +594,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 && !entry->isContainer()
                 && !entry->isCustom()
                 && !entry->isVariant()
-                && !m_metaClasses.findClass(entry->qualifiedCppName())) {
+                && !AbstractMetaClass::findClass(m_metaClasses, entry->qualifiedCppName())) {
                 qCWarning(lcShiboken).noquote().nospace()
                     << QStringLiteral("type '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.")
                                       .arg(entry->qualifiedCppName());
@@ -616,7 +616,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 }
             } else if (entry->isEnum()) {
                 const QString name = ((EnumTypeEntry*) entry)->targetLangQualifier();
-                AbstractMetaClass* cls = m_metaClasses.findClass(name);
+                AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses, name);
 
                 bool enumFound = false;
                 if (cls) {
@@ -1334,9 +1334,9 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::currentTraversedClass(ScopeModelI
     if (m_currentClass)
         fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName()) + colonColon() + fullClassName;
 
-    AbstractMetaClass* metaClass = m_metaClasses.findClass(fullClassName);
+    AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, fullClassName);
     if (!metaClass)
-        metaClass = m_templates.findClass(fullClassName);
+        metaClass = AbstractMetaClass::findClass(m_templates, fullClassName);
     return metaClass;
 }
 
@@ -1822,7 +1822,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
     }
 
     if (primary >= 0) {
-        AbstractMetaClass* baseClass = m_metaClasses.findClass(baseClasses.at(primary));
+        AbstractMetaClass *baseClass = AbstractMetaClass::findClass(m_metaClasses, baseClasses.at(primary));
         if (!baseClass) {
             qCWarning(lcShiboken).noquote().nospace()
                 << QStringLiteral("unknown baseclass for '%1': '%2'")
@@ -1837,7 +1837,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             continue;
 
         if (i != primary) {
-            AbstractMetaClass* baseClass = m_metaClasses.findClass(baseClasses.at(i));
+            AbstractMetaClass *baseClass = AbstractMetaClass::findClass(m_metaClasses, baseClasses.at(i));
             if (!baseClass) {
                 qCWarning(lcShiboken).noquote().nospace()
                     << QStringLiteral("class not found for setup inheritance '%1'").arg(baseClasses.at(i));
@@ -1847,7 +1847,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             setupInheritance(baseClass);
 
             QString interfaceName = baseClass->isInterface() ? InterfaceTypeEntry::interfaceName(baseClass->name()) : baseClass->name();
-            AbstractMetaClass* iface = m_metaClasses.findClass(interfaceName);
+            AbstractMetaClass *iface = AbstractMetaClass::findClass(m_metaClasses, interfaceName);
             if (!iface) {
                 qCWarning(lcShiboken).noquote().nospace()
                     << QStringLiteral("unknown interface for '%1': '%2'").arg(metaClass->name(), interfaceName);
@@ -2580,7 +2580,7 @@ int AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringValu
         return 0;
     }
 
-    AbstractMetaEnumValue* enumValue = m_metaClasses.findEnumValue(stringValue);
+    AbstractMetaEnumValue *enumValue = AbstractMetaClass::findEnumValue(m_metaClasses, stringValue);
     if (enumValue) {
         ok = true;
         return enumValue->value();
@@ -2763,7 +2763,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::findTemplateClass(const QString &
         }
 
         if (!templ)
-            templ = m_metaClasses.findClass(qualifiedName);
+            templ = AbstractMetaClass::findClass(m_metaClasses, qualifiedName);
 
         if (templ)
             return templ;
@@ -2783,7 +2783,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::getBaseClasses(const AbstractM
         if (parent.contains(QLatin1Char('<')))
             cls = findTemplateClass(parent, metaClass);
         else
-            cls = m_metaClasses.findClass(parent);
+            cls = AbstractMetaClass::findClass(m_metaClasses, parent);
 
         if (cls)
             baseClasses << cls;
@@ -3101,7 +3101,7 @@ void AbstractMetaBuilderPrivate::setupExternalConversion(AbstractMetaClass *cls)
     foreach (AbstractMetaFunction* func, convOps) {
         if (func->isModifiedRemoved())
             continue;
-        AbstractMetaClass* metaClass = m_metaClasses.findClass(func->type()->typeEntry());
+        AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type()->typeEntry());
         if (!metaClass)
             continue;
         metaClass->addExternalConversionOperator(func);
diff --git a/ApiExtractor/abstractmetalang.cpp b/ApiExtractor/abstractmetalang.cpp
index cc3283a59..4b890a9d5 100644
--- a/ApiExtractor/abstractmetalang.cpp
+++ b/ApiExtractor/abstractmetalang.cpp
@@ -2644,7 +2644,8 @@ bool AbstractMetaType::isTargetLangFlags() const
  */
 
 
-AbstractMetaEnum *AbstractMetaClassList::findEnum(const EnumTypeEntry *entry) const
+AbstractMetaEnum *AbstractMetaClass::findEnum(const AbstractMetaClassList &classes,
+                                              const EnumTypeEntry *entry)
 {
     Q_ASSERT(entry->isEnum());
 
@@ -2662,7 +2663,7 @@ AbstractMetaEnum *AbstractMetaClassList::findEnum(const EnumTypeEntry *entry) co
         className = TypeDatabase::globalNamespaceClassName(entry);
     }
 
-    AbstractMetaClass *metaClass = findClass(className);
+    AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes, className);
     if (!metaClass) {
         qCWarning(lcShiboken).noquote().nospace()
             << QStringLiteral("AbstractMeta::findEnum(), unknown class '%1' in '%2'")
@@ -2682,7 +2683,8 @@ AbstractMetaEnumValue *AbstractMetaEnumValueList::find(const QString &name) cons
     return 0;
 }
 
-AbstractMetaEnumValue *AbstractMetaClassList::findEnumValue(const QString &name) const
+AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassList &classes,
+                                                        const QString &name)
 {
     QStringList lst = name.split(QLatin1String("::"));
 
@@ -2690,12 +2692,12 @@ AbstractMetaEnumValue *AbstractMetaClassList::findEnumValue(const QString &name)
         QString prefixName = lst.at(0);
         QString enumName = lst.at(1);
 
-        AbstractMetaClass* cl = findClass(prefixName);
+        AbstractMetaClass* cl = findClass(classes, prefixName);
         if (cl)
             return cl->findEnumValue(enumName, 0);
     }
 
-    foreach(AbstractMetaClass* metaClass, *this) {
+    foreach (AbstractMetaClass* metaClass, classes) {
         foreach(AbstractMetaEnum* metaEnum, metaClass->enums()) {
             AbstractMetaEnumValue* enumValue = metaClass->findEnumValue(name, metaEnum);
             if (enumValue)
@@ -2713,22 +2715,23 @@ AbstractMetaEnumValue *AbstractMetaClassList::findEnumValue(const QString &name)
  * C++, Target language base name or complete Target language package.class name.
  */
 
-AbstractMetaClass *AbstractMetaClassList::findClass(const QString &name) const
+AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
+                                                const QString &name)
 {
     if (name.isEmpty())
         return 0;
 
-    foreach (AbstractMetaClass *c, *this) {
+    foreach (AbstractMetaClass *c, classes) {
         if (c->qualifiedCppName() == name)
             return c;
     }
 
-    foreach (AbstractMetaClass *c, *this) {
+    foreach (AbstractMetaClass *c, classes) {
         if (c->fullName() == name)
             return c;
     }
 
-    foreach (AbstractMetaClass *c, *this) {
+    foreach (AbstractMetaClass *c, classes) {
         if (c->name() == name)
             return c;
     }
@@ -2736,9 +2739,10 @@ AbstractMetaClass *AbstractMetaClassList::findClass(const QString &name) const
     return 0;
 }
 
-AbstractMetaClass *AbstractMetaClassList::findClass(const TypeEntry* typeEntry) const
+AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
+                                                const TypeEntry* typeEntry)
 {
-    foreach (AbstractMetaClass* c, *this) {
+    foreach (AbstractMetaClass* c, classes) {
         if (c->typeEntry() == typeEntry)
             return c;
     }
diff --git a/ApiExtractor/abstractmetalang.h b/ApiExtractor/abstractmetalang.h
index 0201e9435..a9502b71a 100644
--- a/ApiExtractor/abstractmetalang.h
+++ b/ApiExtractor/abstractmetalang.h
@@ -98,16 +98,6 @@ private:
 
 };
 
-class AbstractMetaClassList : public  QList<AbstractMetaClass *>
-{
-public:
-    AbstractMetaClass *findClass(const QString &name) const;
-    AbstractMetaClass *findClass(const TypeEntry* typeEntry) const;
-    AbstractMetaEnumValue *findEnumValue(const QString &string) const;
-    AbstractMetaEnum *findEnum(const EnumTypeEntry *entry) const;
-
-};
-
 class AbstractMetaAttributes
 {
     Q_GADGET
@@ -1917,6 +1907,16 @@ public:
     {
         return m_hasToStringCapability;
     }
+
+    static AbstractMetaClass *findClass(const AbstractMetaClassList &classes,
+                                        const QString &name);
+    static AbstractMetaClass *findClass(const AbstractMetaClassList &classes,
+                                        const TypeEntry* typeEntry);
+    static AbstractMetaEnumValue *findEnumValue(const AbstractMetaClassList &classes,
+                                                const QString &string);
+    static AbstractMetaEnum *findEnum(const AbstractMetaClassList &classes,
+                                      const EnumTypeEntry *entry);
+
 private:
 #ifndef QT_NO_DEBUG_STREAM
     friend QDebug operator<<(QDebug d, const AbstractMetaClass *ac);
diff --git a/ApiExtractor/abstractmetalang_typedefs.h b/ApiExtractor/abstractmetalang_typedefs.h
index b167e18e4..dd6573b78 100644
--- a/ApiExtractor/abstractmetalang_typedefs.h
+++ b/ApiExtractor/abstractmetalang_typedefs.h
@@ -31,15 +31,16 @@
 
 #include <QtCore/QList>
 
+class AbstractMetaClass;
 class AbstractMetaField;
 class AbstractMetaArgument;
 class AbstractMetaEnum;
 class AbstractMetaEnumValueList;
 class AbstractMetaFunction;
-class AbstractMetaClassList;
 class AbstractMetaType;
 
 typedef QList<AbstractMetaArgument *> AbstractMetaArgumentList;
+typedef QList<AbstractMetaClass *> AbstractMetaClassList;
 typedef QList<AbstractMetaEnum *> AbstractMetaEnumList;
 typedef QList<AbstractMetaField *> AbstractMetaFieldList;
 typedef QList<AbstractMetaFunction *> AbstractMetaFunctionList;
diff --git a/ApiExtractor/apiextractor.h b/ApiExtractor/apiextractor.h
index 621242850..fcea4a5e1 100644
--- a/ApiExtractor/apiextractor.h
+++ b/ApiExtractor/apiextractor.h
@@ -38,7 +38,6 @@
 
 class AbstractMetaBuilder;
 class AbstractMetaClass;
-class AbstractMetaClassList;
 class AbstractMetaEnum;
 class AbstractMetaFunction;
 class AbstractMetaType;
diff --git a/ApiExtractor/tests/testabstractmetaclass.cpp b/ApiExtractor/tests/testabstractmetaclass.cpp
index 7fc5c1f0f..028522159 100644
--- a/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -109,9 +109,9 @@ void TestAbstractMetaClass::testVirtualMethods()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
-    AbstractMetaClass* a = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* b = classes.findClass(QLatin1String("B"));
-    AbstractMetaClass* c = classes.findClass(QLatin1String("C"));
+    AbstractMetaClass* a = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    AbstractMetaClass* b = AbstractMetaClass::findClass(classes, QLatin1String("B"));
+    AbstractMetaClass* c = AbstractMetaClass::findClass(classes, QLatin1String("C"));
 
     AbstractMetaClass* no_class = 0;
 
@@ -177,7 +177,7 @@ void TestAbstractMetaClass::testDefaultValues()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1);
     AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).first();
     AbstractMetaArgument* arg = method->arguments().first();
@@ -206,7 +206,7 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1);
     AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).first();
     AbstractMetaArgument* arg = method->arguments().first();
@@ -230,10 +230,10 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QVERIFY(classA->isPolymorphic());
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("A::B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("A::B"));
     QVERIFY(classB);
     QVERIFY(!classB->isPolymorphic());
 }
@@ -257,9 +257,9 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    const AbstractMetaClass *classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    const AbstractMetaClass *classB = classes.findClass(QLatin1String("A::B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("A::B"));
     QVERIFY(classB);
     const AbstractMetaFunction *fooF = classB->findFunction(QLatin1String("foo"));
     QVERIFY(fooF);
@@ -289,7 +289,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
 
-    const AbstractMetaClass *classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
@@ -299,7 +299,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     QCOMPARE(assigmentOps.size(), 1);
     QCOMPARE(assigmentOps.first()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction);
 
-    const AbstractMetaClass *classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     ctors = classB->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
@@ -354,7 +354,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 6);
 
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 2);
 
@@ -368,28 +368,28 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QCOMPARE(ctors[1]->arguments().size(), 1);
     QCOMPARE(ctors[1]->minimalSignature(), QLatin1String("A(A)"));
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 2);
     QCOMPARE(classB->functions().first()->minimalSignature(), QLatin1String("B()"));
 
-    AbstractMetaClass* classC = classes.findClass(QLatin1String("C"));
+    AbstractMetaClass* classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classC);
     QCOMPARE(classC->functions().size(), 1);
     QCOMPARE(classC->functions().first()->minimalSignature(), QLatin1String("C(C)"));
 
-    AbstractMetaClass* classD = classes.findClass(QLatin1String("D"));
+    AbstractMetaClass* classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
     QVERIFY(classD);
     QCOMPARE(classD->functions().size(), 1);
     QCOMPARE(classD->functions().first()->minimalSignature(), QLatin1String("D(D)"));
     QVERIFY(classD->functions().first()->isPrivate());
 
-    AbstractMetaClass* classE = classes.findClass(QLatin1String("E"));
+    AbstractMetaClass* classE = AbstractMetaClass::findClass(classes, QLatin1String("E"));
     QVERIFY(classE);
     QVERIFY(classE->hasPrivateDestructor());
     QCOMPARE(classE->functions().size(), 0);
 
-    AbstractMetaClass* classF = classes.findClass(QLatin1String("F"));
+    AbstractMetaClass* classF = AbstractMetaClass::findClass(classes, QLatin1String("F"));
     QVERIFY(classF);
 
     ctors = classF->queryFunctions(AbstractMetaClass::Constructors);
@@ -422,7 +422,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
@@ -436,7 +436,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QCOMPARE(ctors[1]->minimalSignature(), QLatin1String("A(A)"));
     QVERIFY(ctors[1]->isPrivate());
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
 
     ctors = classB->queryFunctions(AbstractMetaClass::Constructors);
@@ -460,7 +460,7 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
@@ -481,7 +481,7 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
@@ -517,10 +517,10 @@ void TestAbstractMetaClass::testIsPolymorphic()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* b = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* b = AbstractMetaClass::findClass(classes, QLatin1String("A"));
 
     QVERIFY(!b->isPolymorphic());
-    AbstractMetaClass* a = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* a = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(!a->isPolymorphic());
 }
 
diff --git a/ApiExtractor/tests/testabstractmetatype.cpp b/ApiExtractor/tests/testabstractmetatype.cpp
index 735ccc2a1..1d52c1e41 100644
--- a/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/ApiExtractor/tests/testabstractmetatype.cpp
@@ -148,7 +148,7 @@ void TestAbstractMetaType::testTypedef()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    AbstractMetaClass* c = classes.findClass(QLatin1String("C"));
+    const AbstractMetaClass *c = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(c);
     QVERIFY(c->isTypeDef());
 }
@@ -198,7 +198,7 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     AbstractMetaFunctionList overloads = classA->queryFunctionsByName(QLatin1String("method"));
     QCOMPARE(overloads.count(), 1);
diff --git a/ApiExtractor/tests/testaddfunction.cpp b/ApiExtractor/tests/testaddfunction.cpp
index 66ae05502..6e1da17ae 100644
--- a/ApiExtractor/tests/testaddfunction.cpp
+++ b/ApiExtractor/tests/testaddfunction.cpp
@@ -86,7 +86,7 @@ void TestAddFunction::testAddFunction()
     QVERIFY(!builder.isNull());
     TypeDatabase* typeDb = TypeDatabase::instance();
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 4); // default ctor, default copy ctor, func a() and the added function
 
@@ -124,7 +124,7 @@ void TestAddFunction::testAddFunctionConstructor()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 3); // default and added ctors
     AbstractMetaFunction* addedFunc = classA->functions().last();
@@ -147,7 +147,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function
     AbstractMetaFunction* addedFunc = classA->functions().last();
@@ -172,7 +172,7 @@ void TestAddFunction::testAddFunctionCodeSnippets()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QVERIFY(addedFunc->hasInjectedCode());
@@ -200,7 +200,7 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
     QVERIFY(addedFunc);
@@ -233,7 +233,7 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
     QVERIFY(addedFunc);
@@ -256,7 +256,7 @@ void TestAddFunction::testAddFunctionAtModuleLevel()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
     TypeDatabase* typeDb = TypeDatabase::instance();
@@ -295,7 +295,7 @@ void TestAddFunction::testAddFunctionWithVarargs()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
     QVERIFY(addedFunc);
@@ -319,7 +319,7 @@ void TestAddFunction::testAddStaticFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func"));
     QVERIFY(addedFunc);
@@ -345,8 +345,10 @@ void TestAddFunction::testAddGlobalFunction()
     QVERIFY(!builder.isNull());
     AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 2);
-    QVERIFY(!builder->classes().findClass(QLatin1String("B"))->findFunction(QLatin1String("globalFunc")));
-    QVERIFY(!builder->classes().findClass(QLatin1String("B"))->findFunction(QLatin1String("globalFunc2")));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), QLatin1String("B"));
+    QVERIFY(classB);
+    QVERIFY(!classB->findFunction(QLatin1String("globalFunc")));
+    QVERIFY(!classB->findFunction(QLatin1String("globalFunc2")));
     QVERIFY(!globalFuncs[0]->injectedCodeSnips().isEmpty());
     QVERIFY(!globalFuncs[1]->injectedCodeSnips().isEmpty());
 }
@@ -390,7 +392,7 @@ void TestAddFunction::testModifyAddedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* foo = classes.findClass(QLatin1String("Foo"));
+    AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("Foo"));
     const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method"));
     QCOMPARE(method->arguments().size(), 2);
     AbstractMetaArgument* arg = method->arguments().at(1);
@@ -418,7 +420,7 @@ void TestAddFunction::testAddFunctionOnTypedef()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* foo = classes.findClass(QLatin1String("FooInt"));
+    AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("FooInt"));
     QVERIFY(foo);
     QVERIFY(foo->hasNonPrivateConstructor());
     AbstractMetaFunctionList lst = foo->queryFunctions(AbstractMetaClass::Constructors);
diff --git a/ApiExtractor/tests/testarrayargument.cpp b/ApiExtractor/tests/testarrayargument.cpp
index 5a99dcf98..5385c9140 100644
--- a/ApiExtractor/tests/testarrayargument.cpp
+++ b/ApiExtractor/tests/testarrayargument.cpp
@@ -49,7 +49,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
     const AbstractMetaArgument* arg = classA->functions().last()->arguments().first();
@@ -75,7 +75,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("A"));
+    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaEnum* someEnum = classA->findEnum(QLatin1String("SomeEnum"));
@@ -106,7 +106,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaEnum* someEnum = builder->globalEnums().first();
diff --git a/ApiExtractor/tests/testcodeinjection.cpp b/ApiExtractor/tests/testcodeinjection.cpp
index 3ed8872bb..ad245633e 100644
--- a/ApiExtractor/tests/testcodeinjection.cpp
+++ b/ApiExtractor/tests/testcodeinjection.cpp
@@ -53,7 +53,7 @@ void TestCodeInjections::testReadFileUtf8()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().constData()));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
     QString code = classA->typeEntry()->codeSnips().first().code();
     QString utf8Data = QString::fromUtf8("\xC3\xA1\xC3\xA9\xC3\xAD\xC3\xB3\xC3\xBA");
@@ -77,7 +77,7 @@ void TestCodeInjections::testInjectWithValidApiVersion()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true, "1.0"));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
 }
 
@@ -97,7 +97,7 @@ void TestCodeInjections::testInjectWithInvalidApiVersion()
     QVERIFY(!builder.isNull());
 
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->typeEntry()->codeSnips().count(), 0);
 }
 
diff --git a/ApiExtractor/tests/testcontainer.cpp b/ApiExtractor/tests/testcontainer.cpp
index ccc6d6bfb..1c79a5a7a 100644
--- a/ApiExtractor/tests/testcontainer.cpp
+++ b/ApiExtractor/tests/testcontainer.cpp
@@ -55,7 +55,7 @@ void TestContainer::testContainerType()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
     //search for class A
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QVERIFY(classA->typeEntry()->baseContainerType());
     QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(classA->typeEntry()->baseContainerType())->type(), ContainerTypeEntry::ListContainer);
@@ -86,7 +86,7 @@ void TestContainer::testListOfValueType()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
 
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->templateBaseClassInstantiations().count(), 1);
     const AbstractMetaType* templateInstanceType = classA->templateBaseClassInstantiations().first();
diff --git a/ApiExtractor/tests/testconversionoperator.cpp b/ApiExtractor/tests/testconversionoperator.cpp
index da8d74792..cae4a3a62 100644
--- a/ApiExtractor/tests/testconversionoperator.cpp
+++ b/ApiExtractor/tests/testconversionoperator.cpp
@@ -53,9 +53,9 @@ void TestConversionOperator::testConversionOperator()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
-    AbstractMetaClass* classC = classes.findClass(QLatin1String("C"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
+    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classA);
     QVERIFY(classB);
     QVERIFY(classC);
@@ -91,7 +91,7 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->externalConversionOperators().count(), 0);
 }
@@ -115,8 +115,8 @@ void TestConversionOperator::testRemovedConversionOperator()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().count(), 2);
@@ -141,8 +141,8 @@ void TestConversionOperator::testConversionOperatorReturningReference()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().count(), 2);
@@ -171,8 +171,8 @@ void TestConversionOperator::testConversionOperatorReturningConstReference()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().count(), 2);
diff --git a/ApiExtractor/tests/testconversionruletag.cpp b/ApiExtractor/tests/testconversionruletag.cpp
index 5a815b277..fb9290795 100644
--- a/ApiExtractor/tests/testconversionruletag.cpp
+++ b/ApiExtractor/tests/testconversionruletag.cpp
@@ -53,7 +53,7 @@ void TestConversionRuleTag::testConversionRuleTagWithFile()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().data()));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const ComplexTypeEntry* typeEntry = classA->typeEntry();
     QVERIFY(typeEntry->hasConversionRule());
@@ -167,7 +167,7 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("Date"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("Date"));
     QVERIFY(classA);
 
     CustomConversion* conversion = classA->typeEntry()->customConversion();
diff --git a/ApiExtractor/tests/testctorinformation.cpp b/ApiExtractor/tests/testctorinformation.cpp
index 582ec2794..a4b4c2388 100644
--- a/ApiExtractor/tests/testctorinformation.cpp
+++ b/ApiExtractor/tests/testctorinformation.cpp
@@ -47,9 +47,9 @@ void TestCtorInformation::testCtorIsPrivate()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
-    QCOMPARE(classes.findClass(QLatin1String("Control"))->hasNonPrivateConstructor(), true);
-    QCOMPARE(classes.findClass(QLatin1String("Subject"))->hasNonPrivateConstructor(), false);
-    QCOMPARE(classes.findClass(QLatin1String("CtorLess"))->hasNonPrivateConstructor(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasNonPrivateConstructor(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasNonPrivateConstructor(), false);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("CtorLess"))->hasNonPrivateConstructor(), true);
 }
 
 void TestCtorInformation::testHasNonPrivateCtor()
@@ -67,9 +67,9 @@ void TestCtorInformation::testHasNonPrivateCtor()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* base = classes.findClass(QLatin1String("Base"));
+    const AbstractMetaClass *base = AbstractMetaClass::findClass(classes, QLatin1String("Base"));
     QCOMPARE(base->hasNonPrivateConstructor(), true);
-    AbstractMetaClass* derived = classes.findClass(QLatin1String("Derived"));
+    const AbstractMetaClass *derived = AbstractMetaClass::findClass(classes, QLatin1String("Derived"));
     QCOMPARE(derived->hasNonPrivateConstructor(), true);
 }
 
diff --git a/ApiExtractor/tests/testdroptypeentries.cpp b/ApiExtractor/tests/testdroptypeentries.cpp
index a64e95409..6b6c5d011 100644
--- a/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/ApiExtractor/tests/testdroptypeentries.cpp
@@ -74,13 +74,13 @@ void TestDropTypeEntries::testDropEntries()
     QVERIFY(!builder.isNull());
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(classes.findClass(QLatin1String("ValueA")));
-    QVERIFY(!classes.findClass(QLatin1String("ValueB")));
-    QVERIFY(classes.findClass(QLatin1String("ObjectA")));
-    QVERIFY(!classes.findClass(QLatin1String("ObjectB")));
-    QVERIFY(classes.findClass(QLatin1String("NamespaceA")));
-    QVERIFY(!classes.findClass(QLatin1String("NamespaceA::InnerClassA")));
-    QVERIFY(!classes.findClass(QLatin1String("NamespaceB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ValueA")));
+    QVERIFY(!AbstractMetaClass::findClass(classes, QLatin1String("ValueB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ObjectA")));
+    QVERIFY(!AbstractMetaClass::findClass(classes, QLatin1String("ObjectB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("NamespaceA")));
+    QVERIFY(!AbstractMetaClass::findClass(classes, QLatin1String("NamespaceA::InnerClassA")));
+    QVERIFY(!AbstractMetaClass::findClass(classes, QLatin1String("NamespaceB")));
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.count(), 1);
@@ -97,13 +97,13 @@ void TestDropTypeEntries::testDontDropEntries()
     QVERIFY(!builder.isNull());
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(classes.findClass(QLatin1String("ValueA")));
-    QVERIFY(classes.findClass(QLatin1String("ValueB")));
-    QVERIFY(classes.findClass(QLatin1String("ObjectA")));
-    QVERIFY(classes.findClass(QLatin1String("ObjectB")));
-    QVERIFY(classes.findClass(QLatin1String("NamespaceA")));
-    QVERIFY(classes.findClass(QLatin1String("NamespaceA::InnerClassA")));
-    QVERIFY(classes.findClass(QLatin1String("NamespaceB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ValueA")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ValueB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ObjectA")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("ObjectB")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("NamespaceA")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("NamespaceA::InnerClassA")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("NamespaceB")));
 
     QCOMPARE(builder->globalEnums().size(), 2);
 
@@ -131,7 +131,7 @@ void TestDropTypeEntries::testDropEntryWithChildTags()
     QStringList droppedEntries(QLatin1String("Foo.ValueA"));
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false, Q_NULLPTR, droppedEntries));
     QVERIFY(!builder.isNull());
-    QVERIFY(!builder->classes().findClass(QLatin1String("ValueA")));
+    QVERIFY(!AbstractMetaClass::findClass(builder->classes(), QLatin1String("ValueA")));
 }
 
 
@@ -139,7 +139,7 @@ void TestDropTypeEntries::testDontDropEntryWithChildTags()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false));
     QVERIFY(!builder.isNull());
-    QVERIFY(builder->classes().findClass(QLatin1String("ValueA")));
+    QVERIFY(AbstractMetaClass::findClass(builder->classes(), QLatin1String("ValueA")));
 }
 
 QTEST_APPLESS_MAIN(TestDropTypeEntries)
diff --git a/ApiExtractor/tests/testdtorinformation.cpp b/ApiExtractor/tests/testdtorinformation.cpp
index c20cf24fb..63b745c12 100644
--- a/ApiExtractor/tests/testdtorinformation.cpp
+++ b/ApiExtractor/tests/testdtorinformation.cpp
@@ -41,8 +41,8 @@ void TestDtorInformation::testDtorIsPrivate()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    QCOMPARE(classes.findClass(QLatin1String("Control"))->hasPrivateDestructor(), false);
-    QCOMPARE(classes.findClass(QLatin1String("Subject"))->hasPrivateDestructor(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasPrivateDestructor(), false);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasPrivateDestructor(), true);
 }
 
 void TestDtorInformation::testDtorIsProtected()
@@ -53,8 +53,8 @@ void TestDtorInformation::testDtorIsProtected()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    QCOMPARE(classes.findClass(QLatin1String("Control"))->hasProtectedDestructor(), false);
-    QCOMPARE(classes.findClass(QLatin1String("Subject"))->hasProtectedDestructor(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasProtectedDestructor(), false);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasProtectedDestructor(), true);
 }
 
 void TestDtorInformation::testDtorIsVirtual()
@@ -65,8 +65,8 @@ void TestDtorInformation::testDtorIsVirtual()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    QCOMPARE(classes.findClass(QLatin1String("Control"))->hasVirtualDestructor(), false);
-    QCOMPARE(classes.findClass(QLatin1String("Subject"))->hasVirtualDestructor(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasVirtualDestructor(), false);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasVirtualDestructor(), true);
 }
 
 void TestDtorInformation::testClassWithVirtualDtorIsPolymorphic()
@@ -77,8 +77,8 @@ void TestDtorInformation::testClassWithVirtualDtorIsPolymorphic()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    QCOMPARE(classes.findClass(QLatin1String("Control"))->isPolymorphic(), true);
-    QCOMPARE(classes.findClass(QLatin1String("Subject"))->isPolymorphic(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->isPolymorphic(), true);
+    QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->isPolymorphic(), true);
 }
 
 QTEST_APPLESS_MAIN(TestDtorInformation)
diff --git a/ApiExtractor/tests/testenum.cpp b/ApiExtractor/tests/testenum.cpp
index 3a90f8eff..6700239d6 100644
--- a/ApiExtractor/tests/testenum.cpp
+++ b/ApiExtractor/tests/testenum.cpp
@@ -67,7 +67,7 @@ void TestEnum::testEnumCppSignature()
     QCOMPARE(functions.first()->arguments().first()->type()->cppSignature(), QLatin1String("A::ClassEnum"));
 
     // enum as parameter of a method
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QCOMPARE(classA->enums().count(), 1);
     AbstractMetaFunctionList funcs = classA->queryFunctionsByName(QLatin1String("method"));
     QVERIFY(!funcs.isEmpty());
@@ -289,7 +289,7 @@ void TestEnum::testEnumValueFromExpression()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
 
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("A"));
+    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
 
     AbstractMetaEnum* enumA = classA->findEnum(QLatin1String("EnumA"));
@@ -356,7 +356,7 @@ void TestEnum::testPrivateEnum()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
 
-    AbstractMetaClass* classA = builder->classes().findClass(QLatin1String("A"));
+    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->enums().count(), 2);
 
diff --git a/ApiExtractor/tests/testextrainclude.cpp b/ApiExtractor/tests/testextrainclude.cpp
index e208a37c0..94158377e 100644
--- a/ApiExtractor/tests/testextrainclude.cpp
+++ b/ApiExtractor/tests/testextrainclude.cpp
@@ -47,7 +47,7 @@ void TestExtraInclude::testClassExtraInclude()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
     QList<Include> includes = classA->typeEntry()->extraIncludes();
@@ -70,7 +70,7 @@ void TestExtraInclude::testGlobalExtraIncludes()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(classes.findClass(QLatin1String("A")));
+    QVERIFY(AbstractMetaClass::findClass(classes, QLatin1String("A")));
 
     TypeDatabase* td = TypeDatabase::instance();
     TypeEntry* module = td->findType(QLatin1String("Foo"));
diff --git a/ApiExtractor/tests/testimplicitconversions.cpp b/ApiExtractor/tests/testimplicitconversions.cpp
index fc97a6038..4438550b2 100644
--- a/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/ApiExtractor/tests/testimplicitconversions.cpp
@@ -55,8 +55,8 @@ void TestImplicitConversions::testWithPrivateCtors()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
 
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classC = classes.findClass(QLatin1String("C"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
     QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classC->typeEntry());
@@ -84,8 +84,8 @@ void TestImplicitConversions::testWithModifiedVisibility()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
     QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classB->typeEntry());
@@ -118,12 +118,12 @@ void TestImplicitConversions::testWithAddedCtor()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
 
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 2);
 
     // Added constructors with custom types should never result in implicit converters.
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     implicitConvs = classB->implicitConversions();
     QCOMPARE(implicitConvs.count(), 0);
 }
@@ -144,8 +144,8 @@ void TestImplicitConversions::testWithExternalConversionOperator()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.count(), 1);
     AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators();
diff --git a/ApiExtractor/tests/testinserttemplate.cpp b/ApiExtractor/tests/testinserttemplate.cpp
index 3205ceb47..ecadf311b 100644
--- a/ApiExtractor/tests/testinserttemplate.cpp
+++ b/ApiExtractor/tests/testinserttemplate.cpp
@@ -50,7 +50,7 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
     QString code = classA->typeEntry()->codeSnips().first().code();
diff --git a/ApiExtractor/tests/testmodifydocumentation.cpp b/ApiExtractor/tests/testmodifydocumentation.cpp
index ab68082e0..96bd0251b 100644
--- a/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -50,7 +50,7 @@ void TestModifyDocumentation::testModifyDocumentation()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
-    AbstractMetaClass *classA = builder->classes().findClass(QLatin1String("A"));
+    AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
     DocModificationList docMods = classA->typeEntry()->docModifications();
     QCOMPARE(docMods.count(), 1);
diff --git a/ApiExtractor/tests/testmodifyfunction.cpp b/ApiExtractor/tests/testmodifyfunction.cpp
index 7e61e56e7..0e6bdc248 100644
--- a/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/ApiExtractor/tests/testmodifyfunction.cpp
@@ -52,7 +52,7 @@ void TestModifyFunction::testRenameArgument()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const AbstractMetaFunction* func = classA->findFunction(QLatin1String("method"));
     Q_ASSERT(func);
 
@@ -80,7 +80,7 @@ void TestModifyFunction::testOwnershipTransfer()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method"));
 
     QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
@@ -127,13 +127,13 @@ void TestModifyFunction::invalidateAfterUse()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false, "0.1"));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("call"));
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
 
-    AbstractMetaClass* classC = classes.findClass(QLatin1String("C"));
+    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classC);
     func = classC->findFunction(QLatin1String("call"));
     QCOMPARE(func->modifications().size(), 1);
@@ -145,7 +145,7 @@ void TestModifyFunction::invalidateAfterUse()
     QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
 
-    AbstractMetaClass* classD =  classes.findClass(QLatin1String("D"));
+    const AbstractMetaClass *classD =  AbstractMetaClass::findClass(classes, QLatin1String("D"));
     QVERIFY(classD);
     func = classD->findFunction(QLatin1String("call"));
     QCOMPARE(func->modifications().size(), 1);
@@ -157,7 +157,7 @@ void TestModifyFunction::invalidateAfterUse()
     QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
     QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
 
-    AbstractMetaClass* classE = classes.findClass(QLatin1String("E"));
+    const AbstractMetaClass *classE = AbstractMetaClass::findClass(classes, QLatin1String("E"));
     QVERIFY(classE);
     func = classE->findFunction(QLatin1String("call"));
     QVERIFY(func);
@@ -199,7 +199,7 @@ void TestModifyFunction::testWithApiVersion()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false, "0.1"));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method"));
 
     QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
diff --git a/ApiExtractor/tests/testmultipleinheritance.cpp b/ApiExtractor/tests/testmultipleinheritance.cpp
index 01c05348d..67c9089ce 100644
--- a/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -59,7 +59,7 @@ void TestMultipleInheritance::testVirtualClass()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 4);
 
-    AbstractMetaClass* classD = classes.findClass(QLatin1String("D"));
+    const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
     bool functionFound = false;
     foreach (AbstractMetaFunction* f, classD->functions()) {
         if (f->name() == QLatin1String("theBug")) {
diff --git a/ApiExtractor/tests/testnamespace.cpp b/ApiExtractor/tests/testnamespace.cpp
index 1a691e632..ca6ce0589 100644
--- a/ApiExtractor/tests/testnamespace.cpp
+++ b/ApiExtractor/tests/testnamespace.cpp
@@ -52,7 +52,7 @@ void NamespaceTest::testNamespaceMembers()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* ns = classes.findClass(QLatin1String("Namespace"));
+    AbstractMetaClass *ns = AbstractMetaClass::findClass(classes, QLatin1String("Namespace"));
     QVERIFY(ns);
     const AbstractMetaEnum* metaEnum = ns->findEnum(QLatin1String("Option"));
     QVERIFY(metaEnum);
@@ -82,11 +82,11 @@ void NamespaceTest::testNamespaceInnerClassMembers()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* ons = classes.findClass(QLatin1String("OuterNamespace"));
+    const AbstractMetaClass *ons = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace"));
     QVERIFY(ons);
-    AbstractMetaClass* ins = classes.findClass(QLatin1String("OuterNamespace::InnerNamespace"));
+    const AbstractMetaClass *ins = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace"));
     QVERIFY(ins);
-    AbstractMetaClass* sc = classes.findClass(QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
+    const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
     QVERIFY(sc);
     const AbstractMetaFunction* meth = sc->findFunction(QLatin1String("method"));
     QVERIFY(meth);
diff --git a/ApiExtractor/tests/testnestedtypes.cpp b/ApiExtractor/tests/testnestedtypes.cpp
index 6dbdb3a71..296aa4385 100644
--- a/ApiExtractor/tests/testnestedtypes.cpp
+++ b/ApiExtractor/tests/testnestedtypes.cpp
@@ -61,10 +61,10 @@ void TestNestedTypes::testNestedTypesModifications()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* ons = classes.findClass(QLatin1String("OuterNamespace"));
+    const AbstractMetaClass *ons = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace"));
     QVERIFY(ons);
 
-    AbstractMetaClass* ins = classes.findClass(QLatin1String("OuterNamespace::InnerNamespace"));
+    const AbstractMetaClass *ins = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace"));
     QVERIFY(ins);
     QCOMPARE(ins->functions().count(), 1);
     QCOMPARE(ins->typeEntry()->codeSnips().count(), 1);
@@ -82,7 +82,7 @@ void TestNestedTypes::testNestedTypesModifications()
     snip = addedFunc->modifications().first().snips.first();
     QCOMPARE(snip.code(), QLatin1String("custom_code2();"));
 
-    AbstractMetaClass* sc = classes.findClass(QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
+    const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
     QVERIFY(ins);
     QCOMPARE(sc->functions().count(), 2); // default constructor and removed method
     AbstractMetaFunction* removedFunc = sc->functions().last();
@@ -109,11 +109,11 @@ void TestNestedTypes::testDuplicationOfNestedTypes()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2);
-    AbstractMetaClass* nspace = classes.findClass(QLatin1String("Namespace"));
+    const AbstractMetaClass *nspace = AbstractMetaClass::findClass(classes, QLatin1String("Namespace"));
     QVERIFY(nspace);
-    AbstractMetaClass* cls1 = classes.findClass(QLatin1String("SomeClass"));
+    const AbstractMetaClass *cls1 = AbstractMetaClass::findClass(classes, QLatin1String("SomeClass"));
     QVERIFY(cls1);
-    AbstractMetaClass* cls2 = classes.findClass(QLatin1String("Namespace::SomeClass"));
+    const AbstractMetaClass *cls2 = AbstractMetaClass::findClass(classes, QLatin1String("Namespace::SomeClass"));
     QVERIFY(cls2);
     QCOMPARE(cls1, cls2);
     QCOMPARE(cls1->name(), QLatin1String("SomeClass"));
diff --git a/ApiExtractor/tests/testprimitivetypetag.cpp b/ApiExtractor/tests/testprimitivetypetag.cpp
index c2e176740..7646dd23a 100644
--- a/ApiExtractor/tests/testprimitivetypetag.cpp
+++ b/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -47,7 +47,7 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
 
     PrimitiveTypeEntry* typeEntry = TypeDatabase::instance()->findPrimitiveType(QLatin1String("A"));
diff --git a/ApiExtractor/tests/testrefcounttag.cpp b/ApiExtractor/tests/testrefcounttag.cpp
index 15f8dde98..e9f9f0ab7 100644
--- a/ApiExtractor/tests/testrefcounttag.cpp
+++ b/ApiExtractor/tests/testrefcounttag.cpp
@@ -53,7 +53,7 @@ void TestRefCountTag::testReferenceCountTag()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject"));
     QVERIFY(func);
     ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first();
@@ -85,7 +85,7 @@ void TestRefCountTag::testWithApiVersion()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false, "0.1"));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject"));
     QVERIFY(func);
     ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first();
diff --git a/ApiExtractor/tests/testreferencetopointer.cpp b/ApiExtractor/tests/testreferencetopointer.cpp
index 1f47f0463..f594cdd25 100644
--- a/ApiExtractor/tests/testreferencetopointer.cpp
+++ b/ApiExtractor/tests/testreferencetopointer.cpp
@@ -47,7 +47,7 @@ void TestReferenceToPointer::testReferenceToPointerArgument()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("dummy"));
     QVERIFY(func);
diff --git a/ApiExtractor/tests/testremovefield.cpp b/ApiExtractor/tests/testremovefield.cpp
index f5cc4611e..7ebe49160 100644
--- a/ApiExtractor/tests/testremovefield.cpp
+++ b/ApiExtractor/tests/testremovefield.cpp
@@ -49,7 +49,7 @@ void TestRemoveField::testRemoveField()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->fields().size(), 1);
     const AbstractMetaField* fieldA = classA->fields().first();
diff --git a/ApiExtractor/tests/testremoveimplconv.cpp b/ApiExtractor/tests/testremoveimplconv.cpp
index 83804c6f3..a81380873 100644
--- a/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/ApiExtractor/tests/testremoveimplconv.cpp
@@ -55,11 +55,11 @@ void TestRemoveImplConv::testRemoveImplConv()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
-    AbstractMetaClass* classC = classes.findClass(QLatin1String("C"));
+    const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classC);
     AbstractMetaFunctionList implConv = classC->implicitConversions();
     QCOMPARE(implConv.count(), 1);
diff --git a/ApiExtractor/tests/testremoveoperatormethod.cpp b/ApiExtractor/tests/testremoveoperatormethod.cpp
index 6fcc80278..6b27227d6 100644
--- a/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -88,7 +88,7 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 14);
     QStringList removedSignatures;
diff --git a/ApiExtractor/tests/testresolvetype.cpp b/ApiExtractor/tests/testresolvetype.cpp
index ea1db9ffd..69691e860 100644
--- a/ApiExtractor/tests/testresolvetype.cpp
+++ b/ApiExtractor/tests/testresolvetype.cpp
@@ -54,7 +54,7 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classD = classes.findClass(QLatin1String("A::D"));
+    const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("A::D"));
     QVERIFY(classD);
     const AbstractMetaFunction* meth = classD->findFunction(QLatin1String("method"));
     QVERIFY(meth);
diff --git a/ApiExtractor/tests/testreverseoperators.cpp b/ApiExtractor/tests/testreverseoperators.cpp
index fc7b408a4..76ba7d3b4 100644
--- a/ApiExtractor/tests/testreverseoperators.cpp
+++ b/ApiExtractor/tests/testreverseoperators.cpp
@@ -47,7 +47,7 @@ void TestReverseOperators::testReverseSum()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 4);
 
@@ -91,11 +91,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 6);
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     QCOMPARE(classB->functions().count(), 4);
 
diff --git a/ApiExtractor/tests/testtemplates.cpp b/ApiExtractor/tests/testtemplates.cpp
index 715d3647b..cb90383db 100644
--- a/ApiExtractor/tests/testtemplates.cpp
+++ b/ApiExtractor/tests/testtemplates.cpp
@@ -69,7 +69,7 @@ void TestTemplates::testTemplateWithNamespace()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("Bookmarks"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("Bookmarks"));
     QVERIFY(classB);
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("list"));
     AbstractMetaType* funcType = func->type();
@@ -104,7 +104,7 @@ void TestTemplates::testTemplateOnContainers()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isNull());
@@ -261,7 +261,7 @@ void TestTemplates::testInheritanceFromContainterTemplate()
     QCOMPARE(classes.count(), 2);
     QCOMPARE(templates.count(), 1);
 
-    const AbstractMetaClass* foobars = classes.findClass(QLatin1String("FooBars"));
+    const AbstractMetaClass* foobars = AbstractMetaClass::findClass(classes, QLatin1String("FooBars"));
     QCOMPARE(foobars->functions().count(), 4);
 
     const AbstractMetaClass* lc = templates.first();
@@ -294,7 +294,7 @@ void TestTemplates::testTemplateInheritanceMixedWithForwardDeclaration()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isNull());
@@ -331,7 +331,7 @@ void TestTemplates::testTemplateInheritanceMixedWithNamespaceAndForwardDeclarati
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("Namespace::B"));
+    AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("Namespace::B"));
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isNull());
@@ -369,9 +369,9 @@ void TestTemplates::testTypedefOfInstantiationOfTemplateClass()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 3);
 
-    const AbstractMetaClass* base = classes.findClass(QLatin1String("BaseTemplateClass"));
+    const AbstractMetaClass* base = AbstractMetaClass::findClass(classes, QLatin1String("BaseTemplateClass"));
     QVERIFY(base);
-    const AbstractMetaClass* one = classes.findClass(QLatin1String("TypeOneClass"));
+    const AbstractMetaClass* one = AbstractMetaClass::findClass(classes, QLatin1String("TypeOneClass"));
     QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
     QCOMPARE(one->functions().count(), base->functions().count());
@@ -418,7 +418,7 @@ void TestTemplates::testContainerTypeIncompleteArgument()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 1);
 
-    AbstractMetaClass* vector = classes.findClass(QLatin1String("IntVector"));
+    AbstractMetaClass* vector = AbstractMetaClass::findClass(classes, QLatin1String("IntVector"));
     QVERIFY(vector);
     QVERIFY(vector->typeEntry()->baseContainerType());
     QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(vector->typeEntry()->baseContainerType())->type(), ContainerTypeEntry::VectorContainer);
diff --git a/ApiExtractor/tests/testtyperevision.cpp b/ApiExtractor/tests/testtyperevision.cpp
index fc67917be..804683140 100644
--- a/ApiExtractor/tests/testtyperevision.cpp
+++ b/ApiExtractor/tests/testtyperevision.cpp
@@ -48,13 +48,13 @@ void TestTypeRevision::testRevisionAttr()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* rev0 = classes.findClass(QLatin1String("Rev_0"));
+    const AbstractMetaClass *rev0 = AbstractMetaClass::findClass(classes, QLatin1String("Rev_0"));
     QCOMPARE(getTypeRevision(rev0->typeEntry()), 0);
 
-    AbstractMetaClass* rev1 = classes.findClass(QLatin1String("Rev_1"));
+    const AbstractMetaClass *rev1 = AbstractMetaClass::findClass(classes, QLatin1String("Rev_1"));
     QCOMPARE(getTypeRevision(rev1->typeEntry()), 1);
 
-    AbstractMetaClass* rev2 = classes.findClass(QLatin1String("Rev_2"));
+    AbstractMetaClass *rev2 = AbstractMetaClass::findClass(classes, QLatin1String("Rev_2"));
     QCOMPARE(getTypeRevision(rev2->typeEntry()), 2);
 
     AbstractMetaEnum* rev3 = rev2->findEnum(QLatin1String("Rev_3"));
diff --git a/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
index deadd1435..627255d37 100644
--- a/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
+++ b/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
@@ -51,12 +51,12 @@ void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
 
     AbstractMetaClassList classes = builder->classes();
 
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QVERIFY(classA->typeEntry()->hasDefaultConstructor());
     QCOMPARE(classA->typeEntry()->defaultConstructor(), QLatin1String("A(0, 0)"));
 
-    AbstractMetaClass* classB = classes.findClass(QLatin1String("B"));
+    const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
     QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
 }
diff --git a/ApiExtractor/tests/testvoidarg.cpp b/ApiExtractor/tests/testvoidarg.cpp
index a13cab7bd..5f0b47389 100644
--- a/ApiExtractor/tests/testvoidarg.cpp
+++ b/ApiExtractor/tests/testvoidarg.cpp
@@ -42,7 +42,7 @@ void TestVoidArg::testVoidParsedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
     QCOMPARE(addedFunc->arguments().count(), 0);
@@ -60,7 +60,7 @@ void TestVoidArg::testVoidAddedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
     QCOMPARE(addedFunc->arguments().count(), 0);
@@ -77,7 +77,7 @@ void TestVoidArg::testVoidPointerParsedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    AbstractMetaClass* classA = classes.findClass(QLatin1String("A"));
+    const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a"));
     QCOMPARE(addedFunc->arguments().count(), 1);
diff --git a/generator/generator.cpp b/generator/generator.cpp
index bde69f152..772ab43cf 100644
--- a/generator/generator.cpp
+++ b/generator/generator.cpp
@@ -400,8 +400,7 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
 AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry* type) const
 {
     if (type->isValue()) {
-        const AbstractMetaClass* metaClass = classes().findClass(type);
-        if (metaClass)
+        if (const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), type))
             return metaClass->implicitConversions();
     }
     return AbstractMetaFunctionList();
@@ -535,7 +534,7 @@ QString Generator::minimalConstructor(const AbstractMetaType* type) const
         QString ctor = cType->defaultConstructor();
         if (!ctor.isEmpty())
             return ctor;
-        ctor = minimalConstructor(classes().findClass(cType));
+        ctor = minimalConstructor(AbstractMetaClass::findClass(classes(), cType));
         if (type->hasInstantiations())
             ctor = ctor.replace(getFullTypeName(cType), getFullTypeNameWithoutModifiers(type));
         return ctor;
@@ -567,7 +566,7 @@ QString Generator::minimalConstructor(const TypeEntry* type) const
     }
 
     if (type->isComplex())
-        return minimalConstructor(classes().findClass(type));
+        return minimalConstructor(AbstractMetaClass::findClass(classes(), type));
 
     return QString();
 }
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index 74c061c8f..7ff280a24 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -2746,7 +2746,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in
         AbstractMetaType *returnType = getTypeWithoutContainer(funcType);
         if (returnType) {
             pyArgName = QLatin1String(PYTHON_RETURN_VAR);
-            *wrappedClass = classes().findClass(returnType->typeEntry()->name());
+            *wrappedClass = AbstractMetaClass::findClass(classes(), returnType->typeEntry()->name());
         } else {
             QString message = QLatin1String("Invalid Argument index (0, return value) on function modification: ")
                 + (funcType ? funcType->name() : QLatin1String("void")) + QLatin1Char(' ');
@@ -2760,7 +2760,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in
         AbstractMetaType* argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type());
 
         if (argType) {
-            *wrappedClass = classes().findClass(argType->typeEntry()->name());
+            *wrappedClass = AbstractMetaClass::findClass(classes(), argType->typeEntry()->name());
             if (argIndex == 1
                 && !func->isConstructor()
                 && OverloadData::isSingleArgument(getFunctionGroups(func->implementingClass())[func->name()]))
@@ -4624,6 +4624,9 @@ void CppGenerator::writeSetattroFunction(QTextStream& s, const AbstractMetaClass
     s << '}' << endl;
 }
 
+static inline QString qObjectClassName() { return QStringLiteral("QObject"); }
+static inline QString qMetaObjectClassName() { return QStringLiteral("QMetaObject"); }
+
 void CppGenerator::writeGetattroFunction(QTextStream& s, const AbstractMetaClass* metaClass)
 {
     s << "static PyObject* " << cpythonGetattroFunctionName(metaClass) << "(PyObject* " PYTHON_SELF_VAR ", PyObject* name)" << endl;
@@ -4631,7 +4634,7 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, const AbstractMetaClass
 
     QString getattrFunc;
     if (usePySideExtensions() && metaClass->isQObject()) {
-        AbstractMetaClass* qobjectClass = classes().findClass(QLatin1String("QObject"));
+        AbstractMetaClass *qobjectClass = AbstractMetaClass::findClass(classes(), qObjectClassName());
         getattrFunc = QString::fromLatin1("PySide::getMetaDataFromQObject(%1, " PYTHON_SELF_VAR ", name)")
                          .arg(cpythonWrapperCPtr(qobjectClass, QLatin1String(PYTHON_SELF_VAR)));
     } else {
@@ -4691,9 +4694,6 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, const AbstractMetaClass
     s << '}' << endl;
 }
 
-static inline QString qObjectClassName() { return QStringLiteral("QObject"); }
-static inline QString qMetaObjectClassName() { return QStringLiteral("QMetaObject"); }
-
 bool CppGenerator::finishGeneration()
 {
     //Generate CPython wrapper file
@@ -4732,8 +4732,8 @@ bool CppGenerator::finishGeneration()
     //We need move QMetaObject register before QObject
     Dependencies additionalDependencies;
     const AbstractMetaClassList &allClasses = classes();
-    if (allClasses.findClass(qObjectClassName()) != Q_NULLPTR
-        && allClasses.findClass(qMetaObjectClassName()) != Q_NULLPTR) {
+    if (AbstractMetaClass::findClass(allClasses, qObjectClassName()) != Q_NULLPTR
+        && AbstractMetaClass::findClass(allClasses, qMetaObjectClassName()) != Q_NULLPTR) {
         Dependency dependency;
         dependency.parent = qMetaObjectClassName();
         dependency.child = qObjectClassName();
diff --git a/generator/shiboken2/headergenerator.cpp b/generator/shiboken2/headergenerator.cpp
index 2c2172fa4..950e938b2 100644
--- a/generator/shiboken2/headergenerator.cpp
+++ b/generator/shiboken2/headergenerator.cpp
@@ -252,7 +252,7 @@ void HeaderGenerator::writeTypeIndexDefineLine(QTextStream& s, const TypeEntry*
     if (typeEntry->isComplex()) {
         const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(typeEntry);
         if (cType->baseContainerType()) {
-            const AbstractMetaClass* metaClass = classes().findClass(cType);
+            const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), cType);
             if (metaClass->templateBaseClass())
                 _writeTypeIndexDefineLine(s, getTypeIndexVariableName(metaClass, true), typeIndex);
         }
diff --git a/generator/shiboken2/overloaddata.cpp b/generator/shiboken2/overloaddata.cpp
index 3bffc5bd8..6258488e0 100644
--- a/generator/shiboken2/overloaddata.cpp
+++ b/generator/shiboken2/overloaddata.cpp
@@ -319,7 +319,7 @@ void OverloadData::sortNextOverloads()
 
         // Process inheritance relationships
         if (targetType->isValue() || targetType->isObject()) {
-            const AbstractMetaClass* metaClass = m_generator->classes().findClass(targetType->typeEntry());
+            const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_generator->classes(), targetType->typeEntry());
             foreach (const AbstractMetaClass* ancestor, m_generator->getAllAncestors(metaClass)) {
                 QString ancestorTypeName = ancestor->typeEntry()->name();
                 if (!sortData.map.contains(ancestorTypeName))
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index 7d851fdff..6238c3190 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -478,7 +478,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
             }
         }
     } else if (arg->type()->typeEntry()->isValue()) {
-        const AbstractMetaClass* metaClass = classes().findClass(arg->type()->typeEntry());
+        const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), arg->type()->typeEntry());
         if (enumValueRegEx.exactMatch(value)&& value != QLatin1String("NULL"))
             prefix = resolveScopePrefix(metaClass, value);
     } else if (arg->type()->isPrimitive() && arg->type()->name() == QLatin1String("int")) {
@@ -960,7 +960,7 @@ bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry* type
 {
     if (!type || !type->isValue())
         return false;
-    return isValueTypeWithCopyConstructorOnly(classes().findClass(type));
+    return isValueTypeWithCopyConstructorOnly(AbstractMetaClass::findClass(classes(), type));
 }
 
 bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType* type) const
@@ -2081,7 +2081,7 @@ AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass*
     AbstractMetaClassList baseClasses;
     if (metaClass) {
         foreach (const QString &parent, metaClass->baseClassNames()) {
-            AbstractMetaClass* clazz = classes().findClass(parent);
+            AbstractMetaClass *clazz = AbstractMetaClass::findClass(classes(), parent);
             if (clazz)
                 baseClasses << clazz;
         }