diff options
Diffstat (limited to 'sources/shiboken6/ApiExtractor')
62 files changed, 731 insertions, 731 deletions
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp index 3a96e46c9..df721cf94 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp @@ -76,13 +76,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() : { } -AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate() -{ - qDeleteAll(m_templates); - qDeleteAll(m_smartPointers); - qDeleteAll(m_metaClasses); -} - AbstractMetaBuilder::AbstractMetaBuilder() : d(new AbstractMetaBuilderPrivate) { d->q = this; @@ -168,8 +161,8 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() QString name = signature.trimmed(); name.truncate(name.indexOf(u'(')); - AbstractMetaClass *clazz = AbstractMetaClass::findClass(m_metaClasses, centry); - if (!clazz) + const auto clazz = AbstractMetaClass::findClass(m_metaClasses, centry); + if (clazz.isNull()) continue; bool found = false; @@ -198,10 +191,10 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() } } -AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument, - const AbstractMetaClass *currentClass) +AbstractMetaClassPtr AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument, + const AbstractMetaClassCPtr ¤tClass) { - AbstractMetaClass *returned = nullptr; + AbstractMetaClassPtr returned; auto type = translateType(argument->type(), currentClass); if (!type.has_value()) return returned; @@ -215,13 +208,13 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentMod * Checks the argument of a hash function and flags the type if it is a complex type */ void AbstractMetaBuilderPrivate::registerHashFunction(const FunctionModelItem &function_item, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { if (function_item->isDeleted()) return; ArgumentList arguments = function_item->arguments(); if (arguments.size() >= 1) { // (Class, Hash seed). - if (AbstractMetaClass *cls = argumentToClass(arguments.at(0), currentClass)) + if (AbstractMetaClassPtr cls = argumentToClass(arguments.at(0), currentClass)) cls->setHashFunction(function_item->name()); } } @@ -240,13 +233,13 @@ void AbstractMetaBuilderPrivate::registerToStringCapabilityIn(const NamespaceMod */ void AbstractMetaBuilderPrivate::registerToStringCapability(const FunctionModelItem &function_item, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { ArgumentList arguments = function_item->arguments(); if (arguments.size() == 2) { if (arguments.at(0)->type().toString() == u"QDebug") { const ArgumentModelItem &arg = arguments.at(1); - if (AbstractMetaClass *cls = argumentToClass(arg, currentClass)) { + if (AbstractMetaClassPtr cls = argumentToClass(arg, currentClass)) { if (arg->type().indirections() < 2) cls->setToStringCapability(true, int(arg->type().indirections())); } @@ -255,7 +248,7 @@ void AbstractMetaBuilderPrivate::registerToStringCapability(const FunctionModelI } void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelItem &item, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { if (item->accessPolicy() != Access::Public) return; @@ -275,8 +268,8 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte } else { auto type = translateType(item->type(), currentClass); const auto retType = type.has_value() ? type->typeEntry() : TypeEntryCPtr{}; - AbstractMetaClass *otherArgClass = argumentToClass(itemArguments.at(1), currentClass); - if (otherArgClass && retType + const auto otherArgClass = argumentToClass(itemArguments.at(1), currentClass); + if (!otherArgClass.isNull() && !retType.isNull() && (retType->isValue() || retType->isObject()) && retType != baseoperandClass->typeEntry() && retType == otherArgClass->typeEntry()) { @@ -284,7 +277,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte firstArgumentIsSelf = false; } } - if (baseoperandClass == nullptr) + if (baseoperandClass.isNull()) return; if (item->isSpaceshipOperator() && !item->isDeleted()) { @@ -334,7 +327,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte } bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem &item, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { ArgumentList itemArguments = item->arguments(); if (itemArguments.size() != 2 || item->accessPolicy() != Access::Public) @@ -364,7 +357,7 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem *streamFunction += AbstractMetaFunction::FinalInTargetLang; streamFunction->setAccess(Access::Public); - AbstractMetaClass *funcClass; + AbstractMetaClassPtr funcClass; if (!streamClass->typeEntry()->generateCode()) { AbstractMetaArgumentList reverseArgs = streamFunction->arguments(); @@ -389,7 +382,7 @@ bool AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum &e2) { return e1.fullName() < e2.fullName(); } -static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2) +static bool metaClassLessThan(const AbstractMetaClassCPtr &c1, const AbstractMetaClassCPtr &c2) { return c1->fullName() < c2->fullName(); } static bool metaFunctionLessThan(const AbstractMetaFunctionCPtr &f1, const AbstractMetaFunctionCPtr &f2) @@ -412,7 +405,7 @@ void AbstractMetaBuilderPrivate::sortLists() } m_metaClasses = classesTopologicalSorted(m_metaClasses, additionalDependencies); - for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) + for (const auto &cls : std::as_const(m_metaClasses)) cls->sortFunctions(); // Ensure that indexes are in alphabetical order, roughly, except @@ -480,7 +473,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, ReportHandler::startProgress("Generating class model (" + QByteArray::number(typeValues.size()) + ")..."); for (const ClassModelItem &item : typeValues) { - if (AbstractMetaClass *cls = traverseClass(dom, item, nullptr)) + if (const auto cls = traverseClass(dom, item, nullptr)) addAbstractMetaClass(cls, item.data()); } @@ -509,7 +502,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, ReportHandler::startProgress("Resolving typedefs (" + QByteArray::number(typeDefs.size()) + ")..."); for (const TypeDefModelItem &typeDef : typeDefs) { - if (AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, nullptr)) + if (const auto cls = traverseTypeDef(dom, typeDef, nullptr)) addAbstractMetaClass(cls, typeDef.data()); } @@ -549,7 +542,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, } ReportHandler::startProgress("Fixing class inheritance..."); - for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) { + for (const auto &cls : std::as_const(m_metaClasses)) { if (cls->needsInheritanceSetup()) { setupInheritance(cls); traverseUsingMembers(cls); @@ -562,7 +555,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, } ReportHandler::startProgress("Detecting inconsistencies in class model..."); - for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) { + for (const auto &cls : std::as_const(m_metaClasses)) { AbstractMetaClass::fixFunctions(cls); if (cls->canAddDefaultConstructor()) @@ -611,12 +604,12 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, } } else if (entry->isEnum() && entry->generateCode()) { const auto enumEntry = qSharedPointerCast<const EnumTypeEntry>(entry); - AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses, - enumEntry->parent()); + const auto cls = AbstractMetaClass::findClass(m_metaClasses, + enumEntry->parent()); - const bool enumFound = cls - ? cls->findEnum(entry->targetLangEntryName()).has_value() - : m_enums.contains(entry); + const bool enumFound = cls.isNull() + ? m_enums.contains(entry) + : cls->findEnum(entry->targetLangEntryName()).has_value(); if (!enumFound) { entry->setCodeGeneration(TypeEntry::GenerateNothing); @@ -658,7 +651,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom, ReportHandler::startProgress("Writing log files..."); - for (AbstractMetaClass *cls : std::as_const(m_metaClasses)) { + for (const auto &cls : std::as_const(m_metaClasses)) { // setupEquals(cls); // setupComparable(cls); setupExternalConversion(cls); @@ -718,7 +711,7 @@ void AbstractMetaBuilder::setLogDirectory(const QString &logDir) d->m_logDirectory.append(QDir::separator()); } -void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls, +void AbstractMetaBuilderPrivate::addAbstractMetaClass(const AbstractMetaClassPtr &cls, const _CodeModelItem *item) { m_itemToClass.insert(item, cls); @@ -732,8 +725,9 @@ void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls, } } -AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModelItem &dom, - const NamespaceModelItem &namespaceItem) +AbstractMetaClassPtr + AbstractMetaBuilderPrivate::traverseNamespace(const FileModelItem &dom, + const NamespaceModelItem &namespaceItem) { QString namespaceName = currentScope()->qualifiedName().join(colonColon()); if (!namespaceName.isEmpty()) @@ -758,17 +752,17 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel } // Continue populating namespace? - AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, type); - if (!metaClass) { - metaClass = new AbstractMetaClass; + AbstractMetaClassPtr metaClass = AbstractMetaClass::findClass(m_metaClasses, type); + if (metaClass.isNull()) { + metaClass.reset(new AbstractMetaClass); metaClass->setTypeEntry(type); addAbstractMetaClass(metaClass, namespaceItem.data()); if (auto extendsType = type->extends()) { - AbstractMetaClass *extended = AbstractMetaClass::findClass(m_metaClasses, extendsType); - if (!extended) { + const auto extended = AbstractMetaClass::findClass(m_metaClasses, extendsType); + if (extended.isNull()) { qCWarning(lcShiboken, "%s", qPrintable(msgNamespaceToBeExtendedNotFound(extendsType->name(), extendsType->targetLangPackage()))); - return nullptr; + return {}; } metaClass->setExtendedNamespace(extended); } @@ -782,8 +776,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel const ClassList &classes = namespaceItem->classes(); for (const ClassModelItem &cls : classes) { - AbstractMetaClass *mjc = traverseClass(dom, cls, metaClass); - if (mjc) { + const auto mjc = traverseClass(dom, cls, metaClass); + if (!mjc.isNull()) { metaClass->addInnerClass(mjc); mjc->setEnclosingClass(metaClass); addAbstractMetaClass(mjc, cls.data()); @@ -794,8 +788,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel // specific typedefs to be used as classes. const TypeDefList typeDefs = namespaceItem->typeDefs(); for (const TypeDefModelItem &typeDef : typeDefs) { - AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, metaClass); - if (cls) { + const auto cls = traverseTypeDef(dom, typeDef, metaClass); + if (!cls.isNull()) { metaClass->addInnerClass(cls); cls->setEnclosingClass(metaClass); addAbstractMetaClass(cls, typeDef.data()); @@ -804,8 +798,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel // Traverse namespaces recursively for (const NamespaceModelItem &ni : namespaceItem->namespaces()) { - AbstractMetaClass *mjc = traverseNamespace(dom, ni); - if (mjc) { + const auto mjc = traverseNamespace(dom, ni); + if (!mjc.isNull()) { metaClass->addInnerClass(mjc); mjc->setEnclosingClass(metaClass); m_classToItem.insert(mjc, ni.data()); // Add for enum lookup. @@ -823,7 +817,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel std::optional<AbstractMetaEnum> AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem, - AbstractMetaClass *enclosing, + const AbstractMetaClassPtr &enclosing, const QSet<QString> &enumsDeclarations) { QString qualifiedName = enumItem->qualifiedName().join(colonColon()); @@ -930,9 +924,9 @@ std::optional<AbstractMetaEnum> return metaEnum; } -AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &, +AbstractMetaClassPtr AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &, const TypeDefModelItem &typeDef, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { TypeDatabase *types = TypeDatabase::instance(); QString className = stripTemplateArgs(typeDef->name()); @@ -972,7 +966,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt if (type.isNull()) return nullptr; - auto *metaClass = new AbstractMetaClass; + AbstractMetaClassPtr metaClass(new AbstractMetaClass); metaClass->setTypeDef(true); metaClass->setTypeEntry(type); metaClass->setBaseClassNames(QStringList(typeDef->type().toString())); @@ -992,7 +986,7 @@ void AbstractMetaBuilderPrivate::traverseTypesystemTypedefs() const auto &entries = TypeDatabase::instance()->typedefEntries(); for (auto it = entries.begin(), end = entries.end(); it != end; ++it) { TypedefEntryPtr te = it.value(); - auto *metaClass = new AbstractMetaClass; + AbstractMetaClassPtr metaClass(new AbstractMetaClass); metaClass->setTypeDef(true); metaClass->setTypeEntry(te->target()); metaClass->setBaseClassNames(QStringList(te->sourceType())); @@ -1018,9 +1012,9 @@ void AbstractMetaBuilderPrivate::traverseTypesystemTypedefs() } } -AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem &dom, +AbstractMetaClassPtr AbstractMetaBuilderPrivate::traverseClass(const FileModelItem &dom, const ClassModelItem &classItem, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { QString className = stripTemplateArgs(classItem->name()); QString fullClassName = className; @@ -1058,7 +1052,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem return nullptr; } - auto *metaClass = new AbstractMetaClass; + AbstractMetaClassPtr metaClass(new AbstractMetaClass); metaClass->setSourceLocation(classItem->sourceLocation()); metaClass->setTypeEntry(type); if ((type->typeFlags() & ComplexTypeEntry::ForceAbstract) != 0) @@ -1109,8 +1103,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem { const ClassList &innerClasses = classItem->classes(); for (const ClassModelItem &ci : innerClasses) { - AbstractMetaClass *cl = traverseClass(dom, ci, metaClass); - if (cl) { + const auto cl = traverseClass(dom, ci, metaClass); + if (!cl.isNull()) { cl->setEnclosingClass(metaClass); metaClass->addInnerClass(cl); addAbstractMetaClass(cl, ci.data()); @@ -1123,8 +1117,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem // specific typedefs to be used as classes. const TypeDefList typeDefs = classItem->typeDefs(); for (const TypeDefModelItem &typeDef : typeDefs) { - AbstractMetaClass *cls = traverseTypeDef(dom, typeDef, metaClass); - if (cls) { + const auto cls = traverseTypeDef(dom, typeDef, metaClass); + if (!cls.isNull()) { cls->setEnclosingClass(metaClass); addAbstractMetaClass(cls, typeDef.data()); } @@ -1138,7 +1132,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem } void AbstractMetaBuilderPrivate::traverseScopeMembers(const ScopeModelItem &item, - AbstractMetaClass *metaClass) + const AbstractMetaClassPtr &metaClass) { // Classes/Namespace members traverseFields(item, metaClass); @@ -1152,15 +1146,12 @@ void AbstractMetaBuilderPrivate::traverseScopeMembers(const ScopeModelItem &item void AbstractMetaBuilderPrivate::traverseClassMembers(const ClassModelItem &item) { - AbstractMetaClass *metaClass = m_itemToClass.value(item.data()); - if (!metaClass) - return; - - // Class members - traverseScopeMembers(item, metaClass); + const auto metaClass = m_itemToClass.value(item.data()); + if (!metaClass.isNull()) // Class members + traverseScopeMembers(item, metaClass); } -void AbstractMetaBuilderPrivate::traverseUsingMembers(AbstractMetaClass *metaClass) +void AbstractMetaBuilderPrivate::traverseUsingMembers(const AbstractMetaClassPtr &metaClass) { const _CodeModelItem *item = m_classToItem.value(metaClass); if (item == nullptr || item->kind() != _CodeModelItem::Kind_Class) @@ -1187,8 +1178,8 @@ void AbstractMetaBuilderPrivate::traverseUsingMembers(AbstractMetaClass *metaCla void AbstractMetaBuilderPrivate::traverseNamespaceMembers(const NamespaceModelItem &item) { - AbstractMetaClass *metaClass = m_itemToClass.value(item.data()); - if (!metaClass) + const auto metaClass = m_itemToClass.value(item.data()); + if (metaClass.isNull()) return; // Namespace members @@ -1213,7 +1204,7 @@ static inline QString qualifiedFieldSignatureWithType(const QString &className, std::optional<AbstractMetaField> AbstractMetaBuilderPrivate::traverseField(const VariableModelItem &field, - const AbstractMetaClass *cls) + const AbstractMetaClassCPtr &cls) { QString fieldName = field->name(); QString className = cls->typeEntry()->qualifiedCppName(); @@ -1276,7 +1267,7 @@ static bool applyFieldModifications(AbstractMetaField *f) } void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item, - AbstractMetaClass *metaClass) + const AbstractMetaClassPtr &metaClass) { const VariableList &variables = scope_item->variables(); for (const VariableModelItem &field : variables) { @@ -1316,7 +1307,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF AbstractMetaFunctionRawPtrList AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem, AbstractMetaClass::Attributes *constructorAttributes, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { *constructorAttributes = {}; AbstractMetaFunctionRawPtrList result; @@ -1342,7 +1333,7 @@ AbstractMetaFunctionRawPtrList } void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem, - AbstractMetaClass *metaClass) + const AbstractMetaClassPtr &metaClass) { AbstractMetaClass::Attributes constructorAttributes; const AbstractMetaFunctionRawPtrList functions = @@ -1430,7 +1421,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem, fillAddedFunctions(metaClass); } -void AbstractMetaBuilderPrivate::fillAddedFunctions(AbstractMetaClass *metaClass) +void AbstractMetaBuilderPrivate::fillAddedFunctions(const AbstractMetaClassPtr &metaClass) { // Add the functions added by the typesystem QString errorMessage; @@ -1513,7 +1504,7 @@ void AbstractMetaBuilderPrivate::applyFunctionModifications(AbstractMetaFunction } } -bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass) +bool AbstractMetaBuilderPrivate::setupInheritance(const AbstractMetaClassPtr &metaClass) { if (metaClass->inheritanceDone()) return true; @@ -1526,9 +1517,9 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass) if (baseClasses.size() == 1 && baseClasses.constFirst().contains(u'<')) { TypeInfo info; ComplexTypeEntryPtr baseContainerType; - auto *templ = findTemplateClass(baseClasses.constFirst(), metaClass, - &info, &baseContainerType); - if (templ) { + const auto templ = findTemplateClass(baseClasses.constFirst(), metaClass, + &info, &baseContainerType); + if (!templ.isNull()) { setupInheritance(templ); inheritTemplate(metaClass, templ, info); metaClass->typeEntry()->setBaseContainerType(templ->typeEntry()); @@ -1594,7 +1585,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass) } void AbstractMetaBuilderPrivate::traverseEnums(const ScopeModelItem &scopeItem, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, const QStringList &enumsDeclarations) { const EnumList &enums = scopeItem->enums(); @@ -1642,7 +1633,7 @@ bool AbstractMetaBuilderPrivate::traverseAddedGlobalFunction(const AddedFunction AbstractMetaFunction * AbstractMetaBuilderPrivate::traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass /* = nullptr */, + const AbstractMetaClassPtr &metaClass /* = {} */, QString *errorMessage) { auto returnType = translateType(addedFunc->returnType(), metaClass, {}, errorMessage); @@ -1726,7 +1717,7 @@ AbstractMetaFunction * } bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, QString *errorMessage) { AbstractMetaFunction *metaFunction = @@ -1899,7 +1890,7 @@ static bool applyArrayArgumentModifications(const FunctionModificationList &func } AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const FunctionModelItem &functionItem, - AbstractMetaClass *currentClass) + const AbstractMetaClassPtr ¤tClass) { if (!functionItem->templateParameters().isEmpty()) return nullptr; @@ -2186,7 +2177,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const Functio return metaFunction; } -static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClass *metaClass, +static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClassCPtr &metaClass, const QString& qualifiedName) { TypeEntryCPtr type; @@ -2201,7 +2192,7 @@ static TypeEntryCPtr findTypeEntryUsingContext(const AbstractMetaClass *metaClas // Helper for findTypeEntries/translateTypeStatic() TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntriesHelper(const QString &qualifiedName, const QString &name, - const AbstractMetaClass *currentClass, + const AbstractMetaClassCPtr ¤tClass, AbstractMetaBuilderPrivate *d) { // 5.1 - Try first using the current scope @@ -2212,7 +2203,7 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntriesHelper(const QString & // 5.1.1 - Try using the class parents' scopes if (d && !currentClass->baseClassNames().isEmpty()) { const auto &baseClasses = d->getBaseClasses(currentClass); - for (const AbstractMetaClass *cls : baseClasses) { + for (const auto &cls : baseClasses) { if (auto type = findTypeEntryUsingContext(cls, qualifiedName)) return {type}; } @@ -2248,7 +2239,7 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntriesHelper(const QString & // and does some error checking. TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntries(const QString &qualifiedName, const QString &name, - const AbstractMetaClass *currentClass, + const AbstractMetaClassCPtr ¤tClass, AbstractMetaBuilderPrivate *d, QString *errorMessage) { @@ -2297,7 +2288,7 @@ TypeEntryCList AbstractMetaBuilderPrivate::findTypeEntries(const QString &qualif // Reverse lookup of AbstractMetaType representing a template specialization // found during traversing function arguments to its type system typedef'ed // class. -const AbstractMetaClass *AbstractMetaBuilderPrivate::resolveTypeSystemTypeDef(const AbstractMetaType &t) const +AbstractMetaClassCPtr AbstractMetaBuilderPrivate::resolveTypeSystemTypeDef(const AbstractMetaType &t) const { if (t.hasInstantiations()) { auto pred = [t](const TypeClassEntry &e) { return e.type.equals(t); }; @@ -2321,7 +2312,7 @@ static void synthesizeWarning(const AbstractMetaFunctionCPtr &f) } static AbstractMetaFunctionPtr - addMethod(AbstractMetaClass *s, const AbstractMetaType &returnType, + addMethod(const AbstractMetaClassPtr &s, const AbstractMetaType &returnType, const QString &name, bool isConst = true) { AbstractMetaFunctionPtr function(new AbstractMetaFunction(name)); @@ -2333,7 +2324,7 @@ static AbstractMetaFunctionPtr } static AbstractMetaFunctionPtr - addMethod(AbstractMetaClass *s, const QString &returnTypeName, + addMethod(const AbstractMetaClassPtr &s, const QString &returnTypeName, const QString &name, bool isConst = true) { auto typeEntry = TypeDatabase::instance()->findPrimitiveType(returnTypeName); @@ -2344,7 +2335,7 @@ static AbstractMetaFunctionPtr } // Create the instantiation type of a smart pointer -static AbstractMetaType instantiationType(const AbstractMetaClass *s, +static AbstractMetaType instantiationType(const AbstractMetaClassCPtr &s, const SmartPointerTypeEntryCPtr &ste) { AbstractMetaType type(s->templateArguments().constFirst()); @@ -2355,7 +2346,7 @@ static AbstractMetaType instantiationType(const AbstractMetaClass *s, } // Create the pointee argument of a smart pointer constructor or reset() -static AbstractMetaArgument pointeeArgument(const AbstractMetaClass *s, +static AbstractMetaArgument pointeeArgument(const AbstractMetaClassCPtr &s, const SmartPointerTypeEntryCPtr &ste) { AbstractMetaArgument pointee; @@ -2366,7 +2357,7 @@ static AbstractMetaArgument pointeeArgument(const AbstractMetaClass *s, // Add the smart pointer constructors. For MSVC, (when not specifying // <system-header>), clang only sees the default constructor. -static void fixSmartPointerConstructors(AbstractMetaClass *s, +static void fixSmartPointerConstructors(const AbstractMetaClassPtr &s, const SmartPointerTypeEntryCPtr &ste) { const auto ctors = s->queryFunctions(FunctionQueryOption::Constructors); @@ -2396,7 +2387,7 @@ static void fixSmartPointerConstructors(AbstractMetaClass *s, } // Similarly, add the smart pointer reset() functions -static void fixSmartPointerReset(AbstractMetaClass *s, +static void fixSmartPointerReset(const AbstractMetaClassPtr &s, const SmartPointerTypeEntryCPtr &ste) { const QString resetMethodName = ste->resetMethod(); @@ -2425,7 +2416,7 @@ static void fixSmartPointerReset(AbstractMetaClass *s, } // Add the relevant missing smart pointer functions. -static void fixSmartPointerClass(AbstractMetaClass *s, +static void fixSmartPointerClass(const AbstractMetaClassPtr &s, const SmartPointerTypeEntryCPtr &ste) { fixSmartPointerConstructors(s, ste); @@ -2454,10 +2445,10 @@ static void fixSmartPointerClass(AbstractMetaClass *s, } // Create a missing smart pointer class -static AbstractMetaClass *createSmartPointerClass(const SmartPointerTypeEntryCPtr &ste, - const AbstractMetaClassList &allClasses) +static AbstractMetaClassPtr createSmartPointerClass(const SmartPointerTypeEntryCPtr &ste, + const AbstractMetaClassList &allClasses) { - auto *result = new AbstractMetaClass(); + AbstractMetaClassPtr result(new AbstractMetaClass()); result->setTypeEntry(qSharedPointerConstCast<SmartPointerTypeEntry>(ste)); TypeEntryCPtr templateArg(new TemplateArgumentEntry(u"T"_s, ste->version(), typeSystemTypeEntry(ste))); @@ -2465,12 +2456,12 @@ static AbstractMetaClass *createSmartPointerClass(const SmartPointerTypeEntryCPt fixSmartPointerClass(result, ste); auto enclosingTe = ste->parent(); if (!enclosingTe->isTypeSystem()) { - auto *enclosing = AbstractMetaClass::findClass(allClasses, enclosingTe); - if (enclosing == nullptr) + const auto enclosing = AbstractMetaClass::findClass(allClasses, enclosingTe); + if (enclosing.isNull()) throw Exception(msgEnclosingClassNotFound(ste)); result->setEnclosingClass(enclosing); auto inner = enclosing->innerClasses(); - inner.append(result); + inner.append(qSharedPointerConstCast<const AbstractMetaClass>(result)); enclosing->setInnerClasses(inner); } return result; @@ -2480,10 +2471,11 @@ void AbstractMetaBuilderPrivate::fixSmartPointers() { const auto smartPointerTypes = TypeDatabase::instance()->smartPointerTypes(); for (const auto &ste : smartPointerTypes) { - const AbstractMetaClass *smartPointerClass = + const auto smartPointerClass = AbstractMetaClass::findClass(m_smartPointers, ste); - if (smartPointerClass) { - fixSmartPointerClass(const_cast<AbstractMetaClass *>(smartPointerClass), ste); + if (!smartPointerClass.isNull()) { + fixSmartPointerClass(qSharedPointerConstCast<AbstractMetaClass>(smartPointerClass), + ste); } else { qCWarning(lcShiboken, "Synthesizing smart pointer \"%s\"...", qPrintable(ste->qualifiedCppName())); @@ -2494,7 +2486,7 @@ void AbstractMetaBuilderPrivate::fixSmartPointers() std::optional<AbstractMetaType> AbstractMetaBuilderPrivate::translateType(const TypeInfo &_typei, - const AbstractMetaClass *currentClass, + const AbstractMetaClassCPtr ¤tClass, TranslateTypeFlags flags, QString *errorMessage) { @@ -2509,7 +2501,7 @@ static bool isNumber(const QString &s) std::optional<AbstractMetaType> AbstractMetaBuilderPrivate::translateTypeStatic(const TypeInfo &_typei, - const AbstractMetaClass *currentClass, + const AbstractMetaClassCPtr ¤tClass, AbstractMetaBuilderPrivate *d, TranslateTypeFlags flags, QString *errorMessageIn) @@ -2724,7 +2716,7 @@ std::optional<AbstractMetaType> std::optional<AbstractMetaType> AbstractMetaBuilder::translateType(const TypeInfo &_typei, - AbstractMetaClass *currentClass, + const AbstractMetaClassPtr ¤tClass, TranslateTypeFlags flags, QString *errorMessage) { @@ -2735,7 +2727,7 @@ std::optional<AbstractMetaType> std::optional<AbstractMetaType> AbstractMetaBuilder::translateType(const QString &t, - AbstractMetaClass *currentClass, + const AbstractMetaClassPtr ¤tClass, TranslateTypeFlags flags, QString *errorMessageIn) { @@ -2815,7 +2807,7 @@ void AbstractMetaBuilder::setCodeModelTestMode(bool b) // Helper to fix a simple default value (field or enum reference) in a // class context. QString AbstractMetaBuilderPrivate::fixSimpleDefaultValue(QStringView expr, - const AbstractMetaClass *klass) const + const AbstractMetaClassCPtr &klass) const { const QString field = qualifyStaticField(klass, expr); @@ -2834,7 +2826,7 @@ QString AbstractMetaBuilderPrivate::fixSimpleDefaultValue(QStringView expr, // see TestResolveType::testFixDefaultArguments() QString AbstractMetaBuilderPrivate::fixDefaultValue(QString expr, const AbstractMetaType &type, - const AbstractMetaClass *implementingClass) const + const AbstractMetaClassCPtr &implementingClass) const { expr.replace(u'\n', u' '); // breaks signature parser @@ -2917,7 +2909,7 @@ QString AbstractMetaBuilderPrivate::fixDefaultValue(QString expr, const Abstract } QString AbstractMetaBuilder::fixDefaultValue(const QString &expr, const AbstractMetaType &type, - const AbstractMetaClass *c) const + const AbstractMetaClassCPtr &c) const { return d->fixDefaultValue(expr, type, c); } @@ -2928,10 +2920,11 @@ bool AbstractMetaBuilderPrivate::isEnum(const FileModelItem &dom, const QStringL return item && item->kind() == _EnumModelItem::__node_kind; } -AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString &name, - const AbstractMetaClass *context, - TypeInfo *info, - ComplexTypeEntryPtr *baseContainerType) const +AbstractMetaClassPtr + AbstractMetaBuilderPrivate::findTemplateClass(const QString &name, + const AbstractMetaClassCPtr &context, + TypeInfo *info, + ComplexTypeEntryPtr *baseContainerType) const { if (baseContainerType) baseContainerType->reset(); @@ -2953,8 +2946,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString & if (info) *info = parsed; - AbstractMetaClass *templ = nullptr; - for (AbstractMetaClass *c : std::as_const(m_templates)) { + AbstractMetaClassPtr templ; + for (const auto &c : std::as_const(m_templates)) { if (c->typeEntry()->name() == qualifiedName) { templ = c; break; @@ -2975,7 +2968,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::findTemplateClass(const QString & } AbstractMetaClassCList - AbstractMetaBuilderPrivate::getBaseClasses(const AbstractMetaClass *metaClass) const + AbstractMetaBuilderPrivate::getBaseClasses(const AbstractMetaClassCPtr &metaClass) const { // Shortcut if inheritance has already been set up if (metaClass->inheritanceDone() || !metaClass->needsInheritanceSetup()) @@ -2983,13 +2976,11 @@ AbstractMetaClassCList AbstractMetaClassCList baseClasses; const QStringList &baseClassNames = metaClass->baseClassNames(); for (const QString& parent : baseClassNames) { - AbstractMetaClass *cls = nullptr; - if (parent.contains(u'<')) - cls = findTemplateClass(parent, metaClass); - else - cls = AbstractMetaClass::findClass(m_metaClasses, parent); + const auto cls = parent.contains(u'<') + ? findTemplateClass(parent, metaClass) + : AbstractMetaClass::findClass(m_metaClasses, parent); - if (cls) + if (!cls.isNull()) baseClasses << cls; } return baseClasses; @@ -3037,26 +3028,26 @@ std::optional<AbstractMetaType> return returned; } -AbstractMetaClass * +AbstractMetaClassPtr AbstractMetaBuilder::inheritTemplateClass(const ComplexTypeEntryPtr &te, - const AbstractMetaClass *templateClass, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags) { - auto result = std::make_unique<AbstractMetaClass>(); + AbstractMetaClassPtr result(new AbstractMetaClass); result->setTypeDef(true); result->setTypeEntry(te); - if (!AbstractMetaBuilderPrivate::inheritTemplate(result.get(), templateClass, + if (!AbstractMetaBuilderPrivate::inheritTemplate(result, templateClass, templateTypes, flags)) { - return nullptr; + return {}; } - AbstractMetaBuilderPrivate::inheritTemplateFunctions(result.get()); - return result.release(); + AbstractMetaBuilderPrivate::inheritTemplateFunctions(result); + return result; } -bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass, - const AbstractMetaClass *templateClass, +bool AbstractMetaBuilderPrivate::inheritTemplate(const AbstractMetaClassPtr &subclass, + const AbstractMetaClassCPtr &templateClass, const TypeInfo &info) { AbstractMetaTypeList templateTypes; @@ -3106,8 +3097,8 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass, return inheritTemplate(subclass, templateClass, templateTypes); } -bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass, - const AbstractMetaClass *templateClass, +bool AbstractMetaBuilderPrivate::inheritTemplate(const AbstractMetaClassPtr &subclass, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags) { @@ -3157,8 +3148,8 @@ AbstractMetaFunctionPtr AbstractMetaFunctionPtr AbstractMetaBuilderPrivate::inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass) + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass) { AbstractMetaFunctionPtr f = inheritTemplateFunction(function, templateTypes); if (f.isNull()) @@ -3215,8 +3206,8 @@ AbstractMetaFunctionPtr AbstractMetaFunctionPtr AbstractMetaBuilder::inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass) + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass) { return AbstractMetaBuilderPrivate::inheritTemplateMember(function, templateTypes, templateClass, subclass); @@ -3224,8 +3215,8 @@ AbstractMetaFunctionPtr static bool doInheritTemplateFunction(const AbstractMetaFunctionCPtr &function, const AbstractMetaFunctionCList &existingSubclassFuncs, - const AbstractMetaClass *templateBaseClass, - const AbstractMetaClass *subclass) + const AbstractMetaClassCPtr &templateBaseClass, + const AbstractMetaClassCPtr &subclass) { // If the function is modified or the instantiation has an equally named // function we are shadowing, so we need to skip it (unless the subclass @@ -3238,7 +3229,7 @@ static bool doInheritTemplateFunction(const AbstractMetaFunctionCPtr &function, || subclass->isUsingMember(templateBaseClass, function->name(), Access::Protected); } -void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *subclass) +void AbstractMetaBuilderPrivate::inheritTemplateFunctions(const AbstractMetaClassPtr &subclass) { auto templateClass = subclass->templateBaseClass(); @@ -3285,7 +3276,7 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub } } -void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass, +void AbstractMetaBuilderPrivate::parseQ_Properties(const AbstractMetaClassPtr &metaClass, const QStringList &declarations) { const QStringList scopes = currentScope()->qualifiedName(); @@ -3325,18 +3316,19 @@ void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass, } } -void AbstractMetaBuilderPrivate::setupExternalConversion(const AbstractMetaClass *cls) +void AbstractMetaBuilderPrivate::setupExternalConversion(const AbstractMetaClassCPtr &cls) { const auto &convOps = cls->operatorOverloads(OperatorQueryOption::ConversionOp); for (const auto &func : convOps) { if (func->isModifiedRemoved()) continue; - AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry()); - if (!metaClass) + const auto metaClass = + AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry()); + if (metaClass.isNull()) continue; metaClass->addExternalConversionOperator(func); } - for (auto *innerClass : cls->innerClasses()) + for (const auto &innerClass : cls->innerClasses()) setupExternalConversion(innerClass); } @@ -3412,10 +3404,10 @@ void AbstractMetaBuilderPrivate::dumpLog() const // AbstractMetaClassList/AbstractMetaClassCList. // Add a dependency of the class associated with typeEntry on clazz. template <class MetaClass> -static bool addClassDependency(const QList<MetaClass *> &classList, +static bool addClassDependency(const QList<QSharedPointer<MetaClass> > &classList, const TypeEntryCPtr &typeEntry, - MetaClass *clazz, - Graph<MetaClass *> *graph) + QSharedPointer<MetaClass> clazz, + Graph<QSharedPointer<MetaClass> > *graph) { if (!typeEntry->isComplex() || typeEntry == clazz->typeEntry()) return false; @@ -3426,10 +3418,11 @@ static bool addClassDependency(const QList<MetaClass *> &classList, } template <class MetaClass> -static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classList, - const Dependencies &additionalDependencies) +static QList<QSharedPointer<MetaClass> > + topologicalSortHelper(const QList<QSharedPointer<MetaClass> > &classList, + const Dependencies &additionalDependencies) { - Graph<MetaClass *> graph(classList.cbegin(), classList.cend()); + Graph<QSharedPointer<MetaClass> > graph(classList.cbegin(), classList.cend()); for (const auto &dep : additionalDependencies) { if (!graph.addEdge(dep.parent, dep.child)) { @@ -3439,14 +3432,14 @@ static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classL } } - for (auto *clazz : classList) { + for (const auto &clazz : classList) { if (auto enclosingC = clazz->enclosingClass()) { - auto enclosing = const_cast<AbstractMetaClass *>(enclosingC); + const auto enclosing = qSharedPointerConstCast<MetaClass>(enclosingC); graph.addEdge(enclosing, clazz); } - for (auto baseClass : clazz->baseClasses()) - graph.addEdge(const_cast<MetaClass *>(baseClass), clazz); + for (const auto &baseClass : clazz->baseClasses()) + graph.addEdge(qSharedPointerConstCast<MetaClass>(baseClass), clazz); for (const auto &func : clazz->functions()) { const AbstractMetaArgumentList &arguments = func->arguments(); @@ -3476,7 +3469,7 @@ static QList<MetaClass *> topologicalSortHelper(const QList<MetaClass *> &classL tempFile.setAutoRemove(false); tempFile.open(); graph.dumpDot(tempFile.fileName(), - [] (const AbstractMetaClass *c) { return c->name(); }); + [] (const AbstractMetaClassCPtr &c) { return c->name(); }); QString message; QTextStream str(&message); diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h index 04069cefc..89239bc7e 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h @@ -80,10 +80,10 @@ public: Q_DECLARE_FLAGS(TranslateTypeFlags, TranslateTypeFlag); static std::optional<AbstractMetaType> - translateType(const TypeInfo &_typei, AbstractMetaClass *currentClass = nullptr, + translateType(const TypeInfo &_typei, const AbstractMetaClassPtr ¤tClass = {}, TranslateTypeFlags flags = {}, QString *errorMessage = nullptr); static std::optional<AbstractMetaType> - translateType(const QString &t, AbstractMetaClass *currentClass = nullptr, + translateType(const QString &t, const AbstractMetaClassPtr ¤tClass = {}, TranslateTypeFlags flags = {}, QString *errorMessage = nullptr); /// Performs a template specialization of the function. @@ -94,9 +94,9 @@ public: inheritTemplateFunction(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes); - static AbstractMetaClass * + static AbstractMetaClassPtr inheritTemplateClass(const ComplexTypeEntryPtr &te, - const AbstractMetaClass *templateClass, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags = {}); @@ -109,22 +109,22 @@ public: static AbstractMetaFunctionPtr inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass); + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass); static QString getSnakeCaseName(const QString &name); // Names under which an item will be registered to Python depending on snakeCase static QStringList definitionNames(const QString &name, TypeSystem::SnakeCase snakeCase); - static QString resolveScopePrefix(const AbstractMetaClass *scope, + static QString resolveScopePrefix(const AbstractMetaClassCPtr &scope, QStringView value); static bool dontFixDefaultValue(QStringView expr); // For testing purposes QString fixDefaultValue(const QString &expr, const AbstractMetaType &type, - const AbstractMetaClass *) const; + const AbstractMetaClassCPtr &) const; QString fixEnumDefault(const AbstractMetaType &type, const QString &expr) const; static void setCodeModelTestMode(bool b); diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp index 7695aabfc..35ca2580f 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_helpers.cpp @@ -30,7 +30,7 @@ static QString resolveScopePrefixHelper(const QStringViewList &scopeList, return name; } -QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClass *scope, +QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClassCPtr &scope, QStringView value) { if (!scope) @@ -45,7 +45,7 @@ QString AbstractMetaBuilder::resolveScopePrefix(const AbstractMetaClass *scope, static QString resolveEnumValueScopePrefix(const AbstractMetaEnum &metaEnum, QStringView value) { - const AbstractMetaClass *scope = metaEnum.enclosingClass(); + AbstractMetaClassCPtr scope = metaEnum.enclosingClass(); if (!scope) return {}; // global enum, value should work as is const QString &qualifiedCppName = scope->qualifiedCppName(); @@ -177,7 +177,7 @@ bool AbstractMetaBuilder::dontFixDefaultValue(QStringView expr) || isIntegerConstant(expr) || isFloatConstant(expr); } -QString AbstractMetaBuilderPrivate::qualifyStaticField(const AbstractMetaClass *c, +QString AbstractMetaBuilderPrivate::qualifyStaticField(const AbstractMetaClassCPtr &c, QStringView field) { if (!c || c->fields().isEmpty()) diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h index 5a6aee3a9..4acdb48d2 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h @@ -29,7 +29,7 @@ public: struct TypeClassEntry { AbstractMetaType type; - const AbstractMetaClass *klass; + AbstractMetaClassCPtr klass; }; using TranslateTypeFlags = AbstractMetaBuilder::TranslateTypeFlags; @@ -37,7 +37,6 @@ public: Q_DISABLE_COPY(AbstractMetaBuilderPrivate) AbstractMetaBuilderPrivate(); - ~AbstractMetaBuilderPrivate(); static FileModelItem buildDom(QByteArrayList arguments, bool addCompilerSupportArguments, @@ -60,57 +59,58 @@ public: NamespaceModelItem currentScope() const { return m_scopes.constLast(); } - AbstractMetaClass *argumentToClass(const ArgumentModelItem &, - const AbstractMetaClass *currentClass); + AbstractMetaClassPtr argumentToClass(const ArgumentModelItem &, + const AbstractMetaClassCPtr ¤tClass); - void addAbstractMetaClass(AbstractMetaClass *cls, const _CodeModelItem *item); - AbstractMetaClass *traverseTypeDef(const FileModelItem &dom, + void addAbstractMetaClass(const AbstractMetaClassPtr &cls, const _CodeModelItem *item); + AbstractMetaClassPtr traverseTypeDef(const FileModelItem &dom, const TypeDefModelItem &typeDef, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); void traverseTypesystemTypedefs(); - AbstractMetaClass *traverseClass(const FileModelItem &dom, + AbstractMetaClassPtr traverseClass(const FileModelItem &dom, const ClassModelItem &item, - AbstractMetaClass *currentClass); - void traverseScopeMembers(const ScopeModelItem &item, AbstractMetaClass *metaClass); + const AbstractMetaClassPtr ¤tClass); + void traverseScopeMembers(const ScopeModelItem &item, + const AbstractMetaClassPtr &metaClass); void traverseClassMembers(const ClassModelItem &scopeItem); - void traverseUsingMembers(AbstractMetaClass *metaClass); + void traverseUsingMembers(const AbstractMetaClassPtr &metaClass); void traverseNamespaceMembers(const NamespaceModelItem &scopeItem); - bool setupInheritance(AbstractMetaClass *metaClass); - AbstractMetaClass *traverseNamespace(const FileModelItem &dom, + bool setupInheritance(const AbstractMetaClassPtr &metaClass); + AbstractMetaClassPtr traverseNamespace(const FileModelItem &dom, const NamespaceModelItem &item); std::optional<AbstractMetaEnum> traverseEnum(const EnumModelItem &item, - AbstractMetaClass *enclosing, + const AbstractMetaClassPtr &enclosing, const QSet<QString> &enumsDeclarations); - void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent, + void traverseEnums(const ScopeModelItem &item, const AbstractMetaClassPtr &parent, const QStringList &enumsDeclarations); AbstractMetaFunctionRawPtrList classFunctionList(const ScopeModelItem &scopeItem, AbstractMetaClass::Attributes *constructorAttributes, - AbstractMetaClass *currentClass); - void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent); + const AbstractMetaClassPtr ¤tClass); + void traverseFunctions(ScopeModelItem item, const AbstractMetaClassPtr &parent); static void applyFunctionModifications(AbstractMetaFunction *func); - void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent); + void traverseFields(const ScopeModelItem &item, const AbstractMetaClassPtr &parent); bool traverseStreamOperator(const FunctionModelItem &functionItem, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); void traverseOperatorFunction(const FunctionModelItem &item, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); AbstractMetaFunction *traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, QString *errorMessage); bool traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc, QString *errorMessage); bool traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, QString *errorMessage); AbstractMetaFunction *traverseFunction(const FunctionModelItem &function, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); std::optional<AbstractMetaField> traverseField(const VariableModelItem &field, - const AbstractMetaClass *cls); + const AbstractMetaClassCPtr &cls); void checkFunctionModifications(); void registerHashFunction(const FunctionModelItem &functionItem, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); void registerToStringCapabilityIn(const NamespaceModelItem &namespaceItem); void registerToStringCapability(const FunctionModelItem &functionItem, - AbstractMetaClass *currentClass); + const AbstractMetaClassPtr ¤tClass); /** * A conversion operator function should not have its owner class as @@ -124,48 +124,49 @@ public: */ static void fixReturnTypeOfConversionOperator(AbstractMetaFunction *metaFunction); - void parseQ_Properties(AbstractMetaClass *metaClass, const QStringList &declarations); - void setupEquals(AbstractMetaClass *metaClass); - void setupComparable(AbstractMetaClass *metaClass); - void setupExternalConversion(const AbstractMetaClass *cls); + void parseQ_Properties(const AbstractMetaClassPtr &metaClass, + const QStringList &declarations); + void setupEquals(const AbstractMetaClassPtr &metaClass); + void setupComparable(const AbstractMetaClassPtr &metaClass); + void setupExternalConversion(const AbstractMetaClassCPtr &cls); static bool isQualifiedCppIdentifier(QStringView e); QString fixDefaultValue(QString expr, const AbstractMetaType &type, - const AbstractMetaClass *) const; + const AbstractMetaClassCPtr &) const; QString fixSimpleDefaultValue(QStringView expr, - const AbstractMetaClass *klass) const; + const AbstractMetaClassCPtr &klass) const; QString fixEnumDefault(const AbstractMetaType &type, const QString &expr) const; /// Qualify a static field name for default value expressions - static QString qualifyStaticField(const AbstractMetaClass *c, QStringView field); + static QString qualifyStaticField(const AbstractMetaClassCPtr &c, QStringView field); std::optional<AbstractMetaType> - translateType(const TypeInfo &type, const AbstractMetaClass *currentClass, + translateType(const TypeInfo &type, const AbstractMetaClassCPtr ¤tClass, TranslateTypeFlags flags = {}, QString *errorMessage = nullptr); static std::optional<AbstractMetaType> - translateTypeStatic(const TypeInfo &type, const AbstractMetaClass *current, + translateTypeStatic(const TypeInfo &type, const AbstractMetaClassCPtr ¤t, AbstractMetaBuilderPrivate *d = nullptr, TranslateTypeFlags flags = {}, QString *errorMessageIn = nullptr); static TypeEntryCList findTypeEntriesHelper(const QString &qualifiedName, const QString &name, - const AbstractMetaClass *currentClass = nullptr, + const AbstractMetaClassCPtr ¤tClass = {}, AbstractMetaBuilderPrivate *d = nullptr); static TypeEntryCList findTypeEntries(const QString &qualifiedName, const QString &name, - const AbstractMetaClass *currentClass = nullptr, + const AbstractMetaClassCPtr ¤tClass = {}, AbstractMetaBuilderPrivate *d = nullptr, QString *errorMessage = nullptr); qint64 findOutValueFromString(const QString &stringValue, bool &ok); - AbstractMetaClass *findTemplateClass(const QString& name, const AbstractMetaClass *context, + AbstractMetaClassPtr findTemplateClass(const QString& name, const AbstractMetaClassCPtr &context, TypeInfo *info = Q_NULLPTR, ComplexTypeEntryPtr *baseContainerType = nullptr) const; - AbstractMetaClassCList getBaseClasses(const AbstractMetaClass *metaClass) const; + AbstractMetaClassCList getBaseClasses(const AbstractMetaClassCPtr &metaClass) const; - static bool inheritTemplate(AbstractMetaClass *subclass, - const AbstractMetaClass *templateClass, + static bool inheritTemplate(const AbstractMetaClassPtr &subclass, + const AbstractMetaClassCPtr &templateClass, const TypeInfo &info); - static bool inheritTemplate(AbstractMetaClass *subclass, - const AbstractMetaClass *templateClass, + static bool inheritTemplate(const AbstractMetaClassPtr &subclass, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags = {}); @@ -176,10 +177,10 @@ public: static AbstractMetaFunctionPtr inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass); + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass); - static void inheritTemplateFunctions(AbstractMetaClass *subclass); + static void inheritTemplateFunctions(const AbstractMetaClassPtr &subclass); static std::optional<AbstractMetaType> inheritTemplateType(const AbstractMetaTypeList &templateTypes, const AbstractMetaType &metaType); @@ -191,8 +192,8 @@ public: void setInclude(const TypeEntryPtr &te, const QString &path) const; static void fixArgumentNames(AbstractMetaFunction *func, const FunctionModificationList &mods); - void fillAddedFunctions(AbstractMetaClass *metaClass); - const AbstractMetaClass *resolveTypeSystemTypeDef(const AbstractMetaType &t) const; + void fillAddedFunctions(const AbstractMetaClassPtr &metaClass); + AbstractMetaClassCPtr resolveTypeSystemTypeDef(const AbstractMetaType &t) const; void fixSmartPointers(); @@ -200,8 +201,8 @@ public: AbstractMetaClassList m_metaClasses; AbstractMetaClassList m_templates; AbstractMetaClassList m_smartPointers; - QHash<const _CodeModelItem *, AbstractMetaClass *> m_itemToClass; - QHash<const AbstractMetaClass *, const _CodeModelItem *> m_classToItem; + QHash<const _CodeModelItem *, AbstractMetaClassPtr > m_itemToClass; + QHash<AbstractMetaClassCPtr, const _CodeModelItem *> m_classToItem; AbstractMetaFunctionCList m_globalFunctions; AbstractMetaEnumList m_globalEnums; diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp index 03e795ec2..ea1aaf0ea 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp @@ -33,7 +33,7 @@ using namespace Qt::StringLiterals; // functions, or typically owner/implementing/declaring class. struct ModificationCacheEntry { - const AbstractMetaClass *klass; + AbstractMetaClassCPtr klass; FunctionModificationList modifications; }; @@ -58,7 +58,7 @@ public: int overloadNumber(const AbstractMetaFunction *q) const; const FunctionModificationList &modifications(const AbstractMetaFunction *q, - const AbstractMetaClass *implementor) const; + const AbstractMetaClassCPtr &implementor) const; bool applyTypeModification(const AbstractMetaFunction *q, const QString &type, int number, QString *errorMessage); @@ -75,9 +75,9 @@ public: AbstractMetaFunction::FunctionType m_functionType = AbstractMetaFunction::NormalFunction; AbstractMetaType m_type; QString m_modifiedTypeName; - const AbstractMetaClass *m_class = nullptr; - const AbstractMetaClass *m_implementingClass = nullptr; - const AbstractMetaClass *m_declaringClass = nullptr; + AbstractMetaClassCPtr m_class; + AbstractMetaClassCPtr m_implementingClass; + AbstractMetaClassCPtr m_declaringClass; mutable ModificationCache m_modificationCache; int m_propertySpecIndex = -1; AbstractMetaArgumentList m_arguments; @@ -272,9 +272,9 @@ void AbstractMetaFunction::setFlags(Flags f) /******************************************************************************* * Indicates that this function has a modification that removes it */ -bool AbstractMetaFunction::isModifiedRemoved(const AbstractMetaClass *cls) const +bool AbstractMetaFunction::isModifiedRemoved(AbstractMetaClassCPtr cls) const { - if (!isInGlobalScope() && cls == nullptr) + if (!isInGlobalScope() && cls.isNull()) cls = d->m_implementingClass; for (const auto &mod : modifications(cls)) { if (mod.isRemoved()) @@ -284,7 +284,7 @@ bool AbstractMetaFunction::isModifiedRemoved(const AbstractMetaClass *cls) const return false; } -bool AbstractMetaFunction::isModifiedFinal(const AbstractMetaClass *cls) const +bool AbstractMetaFunction::isModifiedFinal(AbstractMetaClassCPtr cls) const { if (!isInGlobalScope() && cls == nullptr) cls = d->m_implementingClass; @@ -310,12 +310,12 @@ void AbstractMetaFunction::setType(const AbstractMetaType &type) d->m_type = type; } -const AbstractMetaClass *AbstractMetaFunction::ownerClass() const +AbstractMetaClassCPtr AbstractMetaFunction::ownerClass() const { return d->m_class; } -void AbstractMetaFunction::setOwnerClass(const AbstractMetaClass *cls) +void AbstractMetaFunction::setOwnerClass(const AbstractMetaClassCPtr &cls) { d->m_class = cls; } @@ -482,7 +482,7 @@ bool AbstractMetaFunction::isWhiteListed() const case NormalFunction: case SignalFunction: case SlotFunction: - if (auto *dc = declaringClass()) { + if (auto dc = declaringClass(); !dc.isNull()) { const QSet<QString> &whiteList = dc->typeEntry()->generateFunctions(); return whiteList.isEmpty() || whiteList.contains(d->m_name) || whiteList.contains(minimalSignature()); @@ -590,7 +590,7 @@ int AbstractMetaFunction::actualArgumentIndex(int index) const } // Returns reference counts for argument at idx, or all arguments if idx == -2 -QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClass *cls, int idx) const +QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClassCPtr &cls, int idx) const { QList<ReferenceCount> returned; @@ -605,7 +605,7 @@ QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaCl return returned; } -ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClass *cls, int idx) const +ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClassCPtr &cls, int idx) const { for (const auto &mod : modifications(cls)) { for (const ArgumentModification &argumentMod : mod.argument_mods()) { @@ -654,28 +654,28 @@ bool AbstractMetaFunction::argumentRemoved(int key) const return false; } -const AbstractMetaClass *AbstractMetaFunction::targetLangOwner() const +AbstractMetaClassCPtr AbstractMetaFunction::targetLangOwner() const { return d->m_class && d->m_class->isInvisibleNamespace() ? d->m_class->targetLangEnclosingClass() : d->m_class; } -const AbstractMetaClass *AbstractMetaFunction::declaringClass() const +AbstractMetaClassCPtr AbstractMetaFunction::declaringClass() const { return d->m_declaringClass; } -void AbstractMetaFunction::setDeclaringClass(const AbstractMetaClass *cls) +void AbstractMetaFunction::setDeclaringClass(const AbstractMetaClassCPtr &cls) { d->m_declaringClass = cls; } -const AbstractMetaClass *AbstractMetaFunction::implementingClass() const +AbstractMetaClassCPtr AbstractMetaFunction::implementingClass() const { return d->m_implementingClass; } -void AbstractMetaFunction::setImplementingClass(const AbstractMetaClass *cls) +void AbstractMetaFunction::setImplementingClass(const AbstractMetaClassCPtr &cls) { d->m_implementingClass = cls; } @@ -799,12 +799,12 @@ void AbstractMetaFunction::setSourceLocation(const SourceLocation &sourceLocatio d->m_sourceLocation = sourceLocation; } -static inline TypeSystem::AllowThread allowThreadMod(const AbstractMetaClass *klass) +static inline TypeSystem::AllowThread allowThreadMod(const AbstractMetaClassCPtr &klass) { return klass->typeEntry()->allowThread(); } -static inline bool hasAllowThreadMod(const AbstractMetaClass *klass) +static inline bool hasAllowThreadMod(const AbstractMetaClassCPtr &klass) { return allowThreadMod(klass) != TypeSystem::AllowThread::Unspecified; } @@ -837,7 +837,7 @@ bool AbstractMetaFunction::allowThread() const return result; } -TypeSystem::Ownership AbstractMetaFunction::argumentTargetOwnership(const AbstractMetaClass *cls, int idx) const +TypeSystem::Ownership AbstractMetaFunction::argumentTargetOwnership(const AbstractMetaClassCPtr &cls, int idx) const { for (const auto &modification : modifications(cls)) { for (const ArgumentModification &argumentModification : modification.argument_mods()) { @@ -1005,7 +1005,7 @@ QString AbstractMetaFunction::debugSignature() const } FunctionModificationList AbstractMetaFunction::findClassModifications(const AbstractMetaFunction *f, - const AbstractMetaClass *implementor) + AbstractMetaClassCPtr implementor) { const auto signatures = f->modificationSignatures(); FunctionModificationList mods; @@ -1028,7 +1028,7 @@ FunctionModificationList AbstractMetaFunction::findGlobalModifications(const Abs const FunctionModificationList & AbstractMetaFunctionPrivate::modifications(const AbstractMetaFunction *q, - const AbstractMetaClass *implementor) const + const AbstractMetaClassCPtr &implementor) const { if (!m_addedFunction.isNull()) return m_addedFunction->modifications(); @@ -1045,9 +1045,9 @@ const FunctionModificationList & } const FunctionModificationList & - AbstractMetaFunction::modifications(const AbstractMetaClass *implementor) const + AbstractMetaFunction::modifications(AbstractMetaClassCPtr implementor) const { - if (implementor == nullptr) + if (implementor.isNull()) implementor = d->m_class; return d->modifications(this, implementor); } @@ -1065,7 +1065,7 @@ const DocModificationList AbstractMetaFunction::addedFunctionDocModifications() QString AbstractMetaFunction::argumentName(int index, bool /* create */, - const AbstractMetaClass * /* implementor */) const + AbstractMetaClassCPtr /* implementor */) const { return d->m_arguments[--index].name(); } @@ -1186,12 +1186,12 @@ void AbstractMetaFunction::setExceptionSpecification(ExceptionSpecification e) d->m_exceptionSpecification = e; } -static inline TypeSystem::ExceptionHandling exceptionMod(const AbstractMetaClass *klass) +static inline TypeSystem::ExceptionHandling exceptionMod(const AbstractMetaClassCPtr &klass) { return klass->typeEntry()->exceptionHandling(); } -static inline bool hasExceptionMod(const AbstractMetaClass *klass) +static inline bool hasExceptionMod(const AbstractMetaClassCPtr &klass) { return exceptionMod(klass) != TypeSystem::ExceptionHandling::Unspecified; } diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h index e1f8e774d..6f9bf741a 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h +++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h @@ -241,8 +241,8 @@ public: QString signatureComment() const; QString debugSignature() const; // including virtual/override/final, etc., for debugging only. - bool isModifiedRemoved(const AbstractMetaClass *cls = nullptr) const; - bool isModifiedFinal(const AbstractMetaClass *cls = nullptr) const; + bool isModifiedRemoved(AbstractMetaClassCPtr cls = {}) const; + bool isModifiedFinal(AbstractMetaClassCPtr cls = {}) const; bool isVoid() const; @@ -250,19 +250,19 @@ public: void setType(const AbstractMetaType &type); // The class that has this function as a member. - const AbstractMetaClass *ownerClass() const; - void setOwnerClass(const AbstractMetaClass *cls); + AbstractMetaClassCPtr ownerClass() const; + void setOwnerClass(const AbstractMetaClassCPtr &cls); // Owner excluding invisible namespaces - const AbstractMetaClass *targetLangOwner() const; + AbstractMetaClassCPtr targetLangOwner() const; // The first class in a hierarchy that declares the function - const AbstractMetaClass *declaringClass() const; - void setDeclaringClass(const AbstractMetaClass *cls); + AbstractMetaClassCPtr declaringClass() const; + void setDeclaringClass(const AbstractMetaClassCPtr &cls); // The class that actually implements this function - const AbstractMetaClass *implementingClass() const; - void setImplementingClass(const AbstractMetaClass *cls); + AbstractMetaClassCPtr implementingClass() const; + void setImplementingClass(const AbstractMetaClassCPtr &cls); const AbstractMetaArgumentList &arguments() const; AbstractMetaArgumentList &arguments(); @@ -320,11 +320,13 @@ public: QString conversionRule(TypeSystem::Language language, int idx) const; bool hasConversionRule(TypeSystem::Language language, int idx) const; - QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const; - ArgumentOwner argumentOwner(const AbstractMetaClass *cls, int idx) const; + QList<ReferenceCount> + referenceCounts(const AbstractMetaClassCPtr &cls, int idx = -2) const; + ArgumentOwner argumentOwner(const AbstractMetaClassCPtr &cls, int idx) const; // Returns the ownership rules for the given argument (target lang). - TypeSystem::Ownership argumentTargetOwnership(const AbstractMetaClass *cls, int idx) const; + TypeSystem::Ownership + argumentTargetOwnership(const AbstractMetaClassCPtr &cls, int idx) const; const QString &modifiedTypeName() const; bool isTypeModified() const { return !modifiedTypeName().isEmpty(); } @@ -364,19 +366,19 @@ public: */ bool hasSignatureModifications() const; - const FunctionModificationList &modifications(const AbstractMetaClass *implementor = nullptr) const; + const FunctionModificationList &modifications(AbstractMetaClassCPtr implementor = {}) const; void clearModificationsCache(); const DocModificationList addedFunctionDocModifications() const; static FunctionModificationList findClassModifications(const AbstractMetaFunction *f, - const AbstractMetaClass *implementor); + AbstractMetaClassCPtr implementor); static FunctionModificationList findGlobalModifications(const AbstractMetaFunction *f); /** * Return the argument name if there is a modification the renamed value will be returned */ - QString argumentName(int index, bool create = true, const AbstractMetaClass *cl = nullptr) const; + QString argumentName(int index, bool create = true, AbstractMetaClassCPtr cl = {}) const; int propertySpecIndex() const; void setPropertySpecIndex(int i); diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp index 3586a322e..b7a051d36 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp @@ -60,16 +60,16 @@ public: static AbstractMetaFunction * createFunction(const QString &name, AbstractMetaFunction::FunctionType t, Access access, const AbstractMetaArgumentList &arguments, - const AbstractMetaType &returnType, AbstractMetaClass *q); + const AbstractMetaType &returnType, const AbstractMetaClassPtr &q); void addConstructor(AbstractMetaFunction::FunctionType t, Access access, const AbstractMetaArgumentList &arguments, - AbstractMetaClass *q); - void addUsingConstructors(AbstractMetaClass *q); + const AbstractMetaClassPtr &q); + void addUsingConstructors(const AbstractMetaClassPtr &q); void sortFunctions(); void setFunctions(const AbstractMetaFunctionCList &functions, - AbstractMetaClass *q); - bool isUsingMember(const AbstractMetaClass *c, const QString &memberName, + const AbstractMetaClassCPtr &q); + bool isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName, Access minimumAccess) const; bool hasConstructors() const; qsizetype indexOfProperty(const QString &name) const; @@ -93,13 +93,13 @@ public: Documentation m_doc; - const AbstractMetaClass *m_enclosingClass = nullptr; - const AbstractMetaClass *m_defaultSuperclass = nullptr; + AbstractMetaClassCPtr m_enclosingClass; + AbstractMetaClassCPtr m_defaultSuperclass; AbstractMetaClassCList m_baseClasses; // Real base classes after setting up inheritance AbstractMetaTypeList m_baseTemplateInstantiations; - const AbstractMetaClass *m_extendedNamespace = nullptr; + AbstractMetaClassCPtr m_extendedNamespace; - const AbstractMetaClass *m_templateBaseClass = nullptr; + AbstractMetaClassCPtr m_templateBaseClass; AbstractMetaFunctionCList m_functions; AbstractMetaFieldList m_fields; AbstractMetaEnumList m_enums; @@ -320,12 +320,12 @@ void AbstractMetaClass::sortFunctions() d->sortFunctions(); } -const AbstractMetaClass *AbstractMetaClass::templateBaseClass() const +AbstractMetaClassCPtr AbstractMetaClass::templateBaseClass() const { return d->m_templateBaseClass; } -void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls) +void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClassCPtr &cls) { d->m_templateBaseClass = cls; } @@ -341,7 +341,7 @@ void AbstractMetaClassPrivate::sortFunctions() } void AbstractMetaClassPrivate::setFunctions(const AbstractMetaFunctionCList &functions, - AbstractMetaClass *q) + const AbstractMetaClassCPtr &q) { m_functions = functions; @@ -388,7 +388,8 @@ void AbstractMetaClassPrivate::addFunction(const AbstractMetaFunctionCPtr &funct && function->functionType() == AbstractMetaFunction::ConstructorFunction; } -void AbstractMetaClass::addFunction(AbstractMetaClass *klass, const AbstractMetaFunctionCPtr &function) +void AbstractMetaClass::addFunction(const AbstractMetaClassPtr &klass, + const AbstractMetaFunctionCPtr &function) { auto nonConstF = qSharedPointerConstCast<AbstractMetaFunction>(function); nonConstF->setOwnerClass(klass); @@ -439,17 +440,17 @@ QString AbstractMetaClass::baseClassName() const } // Attribute "default-superclass" -const AbstractMetaClass *AbstractMetaClass::defaultSuperclass() const +AbstractMetaClassCPtr AbstractMetaClass::defaultSuperclass() const { return d->m_defaultSuperclass; } -void AbstractMetaClass::setDefaultSuperclass(AbstractMetaClass *s) +void AbstractMetaClass::setDefaultSuperclass(const AbstractMetaClassPtr &s) { d->m_defaultSuperclass = s; } -const AbstractMetaClass *AbstractMetaClass::baseClass() const +AbstractMetaClassCPtr AbstractMetaClass::baseClass() const { return d->m_baseClasses.value(0, nullptr); } @@ -464,7 +465,7 @@ const AbstractMetaClassCList &AbstractMetaClass::baseClasses() const AbstractMetaClassCList AbstractMetaClass::typeSystemBaseClasses() const { AbstractMetaClassCList result = d->m_baseClasses; - if (d->m_defaultSuperclass != nullptr) { + if (!d->m_defaultSuperclass.isNull()) { result.removeAll(d->m_defaultSuperclass); result.prepend(d->m_defaultSuperclass); } @@ -476,21 +477,21 @@ AbstractMetaClassCList AbstractMetaClass::allTypeSystemAncestors() const { AbstractMetaClassCList result; const auto baseClasses = typeSystemBaseClasses(); - for (auto *base : baseClasses) { + for (const auto &base : baseClasses) { result.append(base); result.append(base->allTypeSystemAncestors()); } return result; } -void AbstractMetaClass::addBaseClass(const AbstractMetaClass *baseClass) +void AbstractMetaClass::addBaseClass(const AbstractMetaClassCPtr &baseClass) { Q_ASSERT(baseClass); d->m_baseClasses.append(baseClass); d->m_isPolymorphic |= baseClass->isPolymorphic(); } -void AbstractMetaClass::setBaseClass(const AbstractMetaClass *baseClass) +void AbstractMetaClass::setBaseClass(const AbstractMetaClassCPtr &baseClass) { if (baseClass) { d->m_baseClasses.prepend(baseClass); @@ -498,12 +499,12 @@ void AbstractMetaClass::setBaseClass(const AbstractMetaClass *baseClass) } } -const AbstractMetaClass *AbstractMetaClass::extendedNamespace() const +AbstractMetaClassCPtr AbstractMetaClass::extendedNamespace() const { return d->m_extendedNamespace; } -void AbstractMetaClass::setExtendedNamespace(const AbstractMetaClass *e) +void AbstractMetaClass::setExtendedNamespace(const AbstractMetaClassCPtr &e) { d->m_extendedNamespace = e; } @@ -513,7 +514,7 @@ const AbstractMetaClassCList &AbstractMetaClass::innerClasses() const return d->m_innerClasses; } -void AbstractMetaClass::addInnerClass(AbstractMetaClass *cl) +void AbstractMetaClass::addInnerClass(const AbstractMetaClassPtr &cl) { d->m_innerClasses << cl; } @@ -808,7 +809,7 @@ bool AbstractMetaClass::hasPrivateCopyConstructor() const void AbstractMetaClassPrivate::addConstructor(AbstractMetaFunction::FunctionType t, Access access, const AbstractMetaArgumentList &arguments, - AbstractMetaClass *q) + const AbstractMetaClassPtr &q) { auto *f = createFunction(q->name(), t, access, arguments, AbstractMetaType::createVoid(), q); if (access != Access::Private) @@ -818,13 +819,13 @@ void AbstractMetaClassPrivate::addConstructor(AbstractMetaFunction::FunctionType addFunction(AbstractMetaFunctionCPtr(f)); } -void AbstractMetaClass::addDefaultConstructor(AbstractMetaClass *klass) +void AbstractMetaClass::addDefaultConstructor(const AbstractMetaClassPtr &klass) { klass->d->addConstructor(AbstractMetaFunction::ConstructorFunction, Access::Public, {}, klass); } -void AbstractMetaClass::addDefaultCopyConstructor(AbstractMetaClass *klass) +void AbstractMetaClass::addDefaultCopyConstructor(const AbstractMetaClassPtr &klass) { AbstractMetaType argType(klass->typeEntry()); argType.setReferenceType(LValueReference); @@ -845,7 +846,7 @@ AbstractMetaFunction * Access access, const AbstractMetaArgumentList &arguments, const AbstractMetaType &returnType, - AbstractMetaClass *q) + const AbstractMetaClassPtr &q) { auto *f = new AbstractMetaFunction(name); f->setType(returnType); @@ -870,7 +871,7 @@ static AbstractMetaType boolType() // Helper to synthesize comparison operators from a spaceship operator. Since // shiboken also generates code for comparing to different types, this fits // better than of handling it in the generator code. -void AbstractMetaClass::addSynthesizedComparisonOperators(AbstractMetaClass *c) +void AbstractMetaClass::addSynthesizedComparisonOperators(const AbstractMetaClassPtr &c) { static const auto returnType = boolType(); @@ -996,7 +997,7 @@ bool AbstractMetaClass::isImplicitlyDefaultConstructible() const return std::all_of(d->m_fields.cbegin(), d->m_fields.cend(), defaultConstructibleField) && std::all_of(d->m_baseClasses.cbegin(), d->m_baseClasses.cend(), - [] (const AbstractMetaClass *c) { + [] (const AbstractMetaClassCPtr &c) { return c->isDefaultConstructible(); }); } @@ -1031,7 +1032,7 @@ bool AbstractMetaClass::isImplicitlyCopyConstructible() const { // Fields are currently not considered return std::all_of(d->m_baseClasses.cbegin(), d->m_baseClasses.cend(), - [] (const AbstractMetaClass *c) { + [] (const AbstractMetaClassCPtr &c) { return c->isCopyConstructible(); }); } @@ -1046,16 +1047,16 @@ bool AbstractMetaClass::canAddDefaultCopyConstructor() const return isImplicitlyCopyConstructible(); } -static bool classHasParentManagement(const AbstractMetaClass *c) +static bool classHasParentManagement(const AbstractMetaClassCPtr &c) { const auto flags = c->typeEntry()->typeFlags(); return flags.testFlag(ComplexTypeEntry::ParentManagement); } -TypeEntryCPtr parentManagementEntry(const AbstractMetaClass *klass) +TypeEntryCPtr parentManagementEntry(const AbstractMetaClassCPtr &klass) { if (klass->typeEntry()->isObject()) { - if (auto *c = recurseClassHierarchy(klass, classHasParentManagement)) + if (auto c = recurseClassHierarchy(klass, classHasParentManagement); !c.isNull()) return c->typeEntry(); } return nullptr; @@ -1125,7 +1126,7 @@ void AbstractMetaClass::addUsingMember(const UsingMember &um) d->m_usingMembers.append(um); } -bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClass *c, +bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName, Access minimumAccess) const { @@ -1136,7 +1137,7 @@ bool AbstractMetaClassPrivate::isUsingMember(const AbstractMetaClass *c, return it != m_usingMembers.cend() && it->access >= minimumAccess; } -bool AbstractMetaClass::isUsingMember(const AbstractMetaClass *c, +bool AbstractMetaClass::isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName, Access minimumAccess) const { @@ -1348,7 +1349,7 @@ void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) co void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const { if (isNamespace()) { - invisibleNamespaceRecursion([enumList](const AbstractMetaClass *c) { + invisibleNamespaceRecursion([enumList](const AbstractMetaClassCPtr &c) { c->getEnumsToBeGenerated(enumList); }); } @@ -1357,7 +1358,7 @@ void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMet void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const { if (isNamespace()) { - invisibleNamespaceRecursion([funcList](const AbstractMetaClass *c) { + invisibleNamespaceRecursion([funcList](const AbstractMetaClassCPtr &c) { funcList->append(c->functions()); }); } @@ -1368,7 +1369,8 @@ QString AbstractMetaClass::fullName() const return package() + u'.' + d->m_typeEntry->targetLangName(); } -static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType &type) +static void addExtraIncludeForType(const AbstractMetaClassPtr &metaClass, + const AbstractMetaType &type) { Q_ASSERT(metaClass); @@ -1385,11 +1387,11 @@ static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractM } } -static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, +static void addExtraIncludesForFunction(const AbstractMetaClassPtr &metaClass, const AbstractMetaFunctionCPtr &meta_function) { Q_ASSERT(metaClass); - Q_ASSERT(meta_function); + Q_ASSERT(!meta_function.isNull()); addExtraIncludeForType(metaClass, meta_function->type()); const AbstractMetaArgumentList &arguments = meta_function->arguments(); @@ -1420,7 +1422,7 @@ static bool addSuperFunction(const AbstractMetaFunctionCPtr &f) // Add constructors imported via "using" from the base classes. This is not // needed for normal hidden inherited member functions since we generate a // cast to the base class to call them into binding code. -void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q) +void AbstractMetaClassPrivate::addUsingConstructors(const AbstractMetaClassPtr &q) { // Restricted to the non-constructor case currently to avoid // having to compare the parameter lists of existing constructors. @@ -1429,7 +1431,7 @@ void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q) return; } - for (auto superClass : m_baseClasses) { + for (const auto &superClass : m_baseClasses) { // Find any "using base-constructor" directives if (isUsingMember(superClass, superClass->name(), Access::Protected)) { // Add to derived class with parameter lists. @@ -1444,7 +1446,7 @@ void AbstractMetaClassPrivate::addUsingConstructors(AbstractMetaClass *q) } } -void AbstractMetaClass::fixFunctions(AbstractMetaClass *klass) +void AbstractMetaClass::fixFunctions(const AbstractMetaClassPtr &klass) { auto *d = klass->d.data(); if (d->m_functionsFixed) @@ -1466,8 +1468,8 @@ void AbstractMetaClass::fixFunctions(AbstractMetaClass *klass) nonRemovedFuncs.append(f); } - for (auto *superClassC : d->m_baseClasses) { - auto *superClass = const_cast<AbstractMetaClass *>(superClassC); + for (const auto &superClassC : d->m_baseClasses) { + auto superClass = qSharedPointerConstCast<AbstractMetaClass>(superClassC); AbstractMetaClass::fixFunctions(superClass); // Since we always traverse the complete hierarchy we are only // interrested in what each super class implements, not what @@ -1695,11 +1697,11 @@ std::optional<AbstractMetaEnumValue> if (lst.size() > 1) { const auto &prefixName = lst.at(0); const auto &enumName = lst.at(1); - if (auto *cl = findClass(classes, prefixName)) + if (auto cl = findClass(classes, prefixName); !cl.isNull()) return cl->findEnumValue(enumName.toString()); } - for (AbstractMetaClass *metaClass : classes) { + for (const auto &metaClass : classes) { auto enumValue = metaClass->findEnumValue(name); if (enumValue.has_value()) return enumValue; @@ -1742,31 +1744,31 @@ static It findClassHelper(It begin, It end, QStringView name) return end; } -AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes, - QStringView name) +AbstractMetaClassPtr AbstractMetaClass::findClass(const AbstractMetaClassList &classes, + QStringView name) { auto it =findClassHelper(classes.cbegin(), classes.cend(), name); return it != classes.cend() ? *it : nullptr; } -const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCList &classes, - QStringView name) +AbstractMetaClassCPtr AbstractMetaClass::findClass(const AbstractMetaClassCList &classes, + QStringView name) { auto it = findClassHelper(classes.cbegin(), classes.cend(), name); return it != classes.cend() ? *it : nullptr; } -AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes, - const TypeEntryCPtr &typeEntry) +AbstractMetaClassPtr AbstractMetaClass::findClass(const AbstractMetaClassList &classes, + const TypeEntryCPtr &typeEntry) { - for (AbstractMetaClass *c : classes) { + for (AbstractMetaClassPtr c : classes) { if (c->typeEntry() == typeEntry) return c; } return nullptr; } -const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCList &classes, +AbstractMetaClassCPtr AbstractMetaClass::findClass(const AbstractMetaClassCList &classes, const TypeEntryCPtr &typeEntry) { for (auto c : classes) { @@ -1777,19 +1779,19 @@ const AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassCLi } /// Returns true if this class is a subclass of the given class -bool inheritsFrom(const AbstractMetaClass *c, const AbstractMetaClass *cls) +bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &cls) { Q_ASSERT(cls != nullptr); if (c == cls || c->templateBaseClass() == cls) return true; - return recurseClassHierarchy(c, [cls](const AbstractMetaClass *c) { - return cls == c; - }) != nullptr; + return !recurseClassHierarchy(c, [cls](const AbstractMetaClassCPtr &c) { + return cls.data() == c.data(); + }).isNull(); } -bool inheritsFrom(const AbstractMetaClass *c, const QString &name) +bool inheritsFrom(const AbstractMetaClassCPtr &c, const QString &name) { if (c->qualifiedCppName() == name) return true; @@ -1799,19 +1801,19 @@ bool inheritsFrom(const AbstractMetaClass *c, const QString &name) return true; } - return recurseClassHierarchy(c, [&name](const AbstractMetaClass *c) { + return !recurseClassHierarchy(c, [&name](const AbstractMetaClassCPtr &c) { return c->qualifiedCppName() == name; - }) != nullptr; + }).isNull(); } -const AbstractMetaClass *findBaseClass(const AbstractMetaClass *c, - const QString &qualifiedName) +AbstractMetaClassCPtr findBaseClass(const AbstractMetaClassCPtr &c, + const QString &qualifiedName) { - auto *tp = c->templateBaseClass(); - if (tp != nullptr && tp->qualifiedCppName() == qualifiedName) + auto tp = c->templateBaseClass(); + if (!tp.isNull() && tp->qualifiedCppName() == qualifiedName) return tp; - return recurseClassHierarchy(c, [&qualifiedName](const AbstractMetaClass *c) { + return recurseClassHierarchy(c, [&qualifiedName](const AbstractMetaClassCPtr &c) { return c->qualifiedCppName() == qualifiedName; }); } @@ -1841,7 +1843,7 @@ void AbstractMetaClass::setValueTypeWithCopyConstructorOnly(bool v) d->m_valueTypeWithCopyConstructorOnly = v; } -bool AbstractMetaClass::determineValueTypeWithCopyConstructorOnly(const AbstractMetaClass *c, +bool AbstractMetaClass::determineValueTypeWithCopyConstructorOnly(const AbstractMetaClassCPtr &c, bool avoidProtectedHack) { @@ -1907,7 +1909,7 @@ void AbstractMetaClass::format(QDebug &debug) const if (!d->m_baseClasses.isEmpty()) { debug << ", inherits "; - for (auto b : d->m_baseClasses) + for (const auto &b : d->m_baseClasses) debug << " \"" << b->name() << '"'; } @@ -1982,7 +1984,7 @@ QDebug operator<<(QDebug debug, const UsingMember &d) return debug; } -QDebug operator<<(QDebug d, const AbstractMetaClass *ac) +QDebug operator<<(QDebug d, const AbstractMetaClassCPtr &ac) { QDebugStateSaver saver(d); d.noquote(); diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h index ce0127580..9eb5e67d6 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h @@ -67,7 +67,8 @@ public: const AbstractMetaFunctionCList &functions() const; void setFunctions(const AbstractMetaFunctionCList &functions); - static void addFunction(AbstractMetaClass *klass, const AbstractMetaFunctionCPtr &function); + static void addFunction(const AbstractMetaClassPtr &klass, + const AbstractMetaFunctionCPtr &function); bool hasFunction(const QString &str) const; AbstractMetaFunctionCPtr findFunction(QStringView functionName) const; AbstractMetaFunctionCList findFunctions(QStringView functionName) const; @@ -81,8 +82,8 @@ public: bool hasCopyConstructor() const; bool hasPrivateCopyConstructor() const; - static void addDefaultConstructor(AbstractMetaClass *klass); - static void addDefaultCopyConstructor(AbstractMetaClass *klass); + static void addDefaultConstructor(const AbstractMetaClassPtr &klass); + static void addDefaultCopyConstructor(const AbstractMetaClassPtr &klass); bool hasNonPrivateConstructor() const; void setHasNonPrivateConstructor(bool value); @@ -113,7 +114,7 @@ public: bool isImplicitlyCopyConstructible() const; bool canAddDefaultCopyConstructor() const; - static void addSynthesizedComparisonOperators(AbstractMetaClass *c); + static void addSynthesizedComparisonOperators(const AbstractMetaClassPtr &c); bool generateExceptionHandling() const; @@ -121,7 +122,7 @@ public: const UsingMembers &usingMembers() const; void addUsingMember(const UsingMember &um); - bool isUsingMember(const AbstractMetaClass *c, const QString &memberName, + bool isUsingMember(const AbstractMetaClassCPtr &c, const QString &memberName, Access minimumAccess) const; bool hasUsingMemberFor(const QString &memberName) const; @@ -186,27 +187,27 @@ public: QString baseClassName() const; - const AbstractMetaClass *defaultSuperclass() const; // Attribute "default-superclass" - void setDefaultSuperclass(AbstractMetaClass *s); + AbstractMetaClassCPtr defaultSuperclass() const; // Attribute "default-superclass" + void setDefaultSuperclass(const AbstractMetaClassPtr &s); - const AbstractMetaClass *baseClass() const; + AbstractMetaClassCPtr baseClass() const; const AbstractMetaClassCList &baseClasses() const; // base classes including defaultSuperclass AbstractMetaClassCList typeSystemBaseClasses() const; // Recursive list of all base classes including defaultSuperclass AbstractMetaClassCList allTypeSystemAncestors() const; - void addBaseClass(const AbstractMetaClass *base_class); - void setBaseClass(const AbstractMetaClass *base_class); + void addBaseClass(const AbstractMetaClassCPtr &base_class); + void setBaseClass(const AbstractMetaClassCPtr &base_class); /** * \return the namespace from another package which this namespace extends. */ - const AbstractMetaClass *extendedNamespace() const; - void setExtendedNamespace(const AbstractMetaClass *e); + AbstractMetaClassCPtr extendedNamespace() const; + void setExtendedNamespace(const AbstractMetaClassCPtr &e); const AbstractMetaClassCList &innerClasses() const; - void addInnerClass(AbstractMetaClass *cl); + void addInnerClass(const AbstractMetaClassPtr &cl); void setInnerClasses(const AbstractMetaClassCList &innerClasses); QString package() const; @@ -285,8 +286,8 @@ public: void sortFunctions(); - const AbstractMetaClass *templateBaseClass() const; - void setTemplateBaseClass(const AbstractMetaClass *cls); + AbstractMetaClassCPtr templateBaseClass() const; + void setTemplateBaseClass(const AbstractMetaClassCPtr &cls); bool hasTemplateBaseClassInstantiations() const; const AbstractMetaTypeList &templateBaseClassInstantiations() const; @@ -310,18 +311,18 @@ public: bool isCopyable() const; bool isValueTypeWithCopyConstructorOnly() const; void setValueTypeWithCopyConstructorOnly(bool v); - static bool determineValueTypeWithCopyConstructorOnly(const AbstractMetaClass *c, + static bool determineValueTypeWithCopyConstructorOnly(const AbstractMetaClassCPtr &c, bool avoidProtectedHack); - static AbstractMetaClass *findClass(const AbstractMetaClassList &classes, + static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes, QStringView name); - static const AbstractMetaClass *findClass(const AbstractMetaClassCList &classes, + static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes, QStringView name); - static AbstractMetaClass *findClass(const AbstractMetaClassList &classes, + static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes, const TypeEntryCPtr &typeEntry); - static const AbstractMetaClass *findClass(const AbstractMetaClassCList &classes, + static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes, const TypeEntryCPtr &typeEntry); - const AbstractMetaClass *findBaseClass(const QString &qualifiedName) const; + AbstractMetaClassCPtr findBaseClass(const QString &qualifiedName) const; static std::optional<AbstractMetaEnumValue> findEnumValue(const AbstractMetaClassList &classes, const QString &string); @@ -330,7 +331,7 @@ public: void setSourceLocation(const SourceLocation &sourceLocation); // For AbstractMetaBuilder - static void fixFunctions(AbstractMetaClass *klass); + static void fixFunctions(const AbstractMetaClassPtr &klass); bool needsInheritanceSetup() const; void setInheritanceDone(bool b); bool inheritanceDone() const; @@ -342,7 +343,7 @@ private: #ifndef QT_NO_DEBUG_STREAM void format(QDebug &d) const; void formatMembers(QDebug &d) const; - friend QDebug operator<<(QDebug d, const AbstractMetaClass *ac); + friend QDebug operator<<(QDebug d, const AbstractMetaClassCPtr &ac); #endif QScopedPointer<AbstractMetaClassPrivate> d; @@ -361,7 +362,7 @@ inline bool AbstractMetaClass::isAbstract() const template <class Function> void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const { - for (auto ic : innerClasses()) { + for (const auto &ic : innerClasses()) { if (ic->isInvisibleNamespace()) { f(ic); ic->invisibleNamespaceRecursion(f); @@ -369,16 +370,16 @@ void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const } } -bool inheritsFrom(const AbstractMetaClass *c, const AbstractMetaClass *other); -bool inheritsFrom(const AbstractMetaClass *c, const QString &name); +bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &other); +bool inheritsFrom(const AbstractMetaClassCPtr &c, const QString &name); +inline bool isQObject(const AbstractMetaClassCPtr &c) { return inheritsFrom(c, u"QObject"_qs); } -inline bool isQObject(const AbstractMetaClass *c) { return inheritsFrom(c, u"QObject"_qs); } +AbstractMetaClassCPtr findBaseClass(const AbstractMetaClassCPtr &c, + const QString &qualifiedName); -const AbstractMetaClass *findBaseClass(const AbstractMetaClass *c, - const QString &qualifiedName); /// Return type entry of the base class that declares the parent management -TypeEntryCPtr parentManagementEntry(const AbstractMetaClass *klass); -inline bool hasParentManagement(const AbstractMetaClass *c) +TypeEntryCPtr parentManagementEntry(const AbstractMetaClassCPtr &klass); +inline bool hasParentManagement(const AbstractMetaClassCPtr &c) { return !parentManagementEntry(c).isNull(); } Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::CppWrapper); diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h b/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h index c1deea2c2..a70c769c8 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang_helpers.h @@ -4,21 +4,24 @@ #ifndef ABSTRACTMETALANG_HELPERS_H #define ABSTRACTMETALANG_HELPERS_H +#include "abstractmetalang_typedefs.h" + template <class MetaClass> -MetaClass *findByName(QList<MetaClass *> haystack, QStringView needle) +QSharedPointer<MetaClass> findByName(const QList<QSharedPointer<MetaClass> > &haystack, + QStringView needle) { - for (MetaClass *c : haystack) { + for (const auto &c : haystack) { if (c->name() == needle) return c; } - return nullptr; + return {}; } // Helper for recursing the base classes of an AbstractMetaClass. // Returns the class for which the predicate is true. template <class Predicate> -const AbstractMetaClass *recurseClassHierarchy(const AbstractMetaClass *klass, - Predicate pred) +AbstractMetaClassCPtr recurseClassHierarchy(const AbstractMetaClassCPtr &klass, + Predicate pred) { if (pred(klass)) return klass; @@ -26,7 +29,7 @@ const AbstractMetaClass *recurseClassHierarchy(const AbstractMetaClass *klass, if (auto r = recurseClassHierarchy(base, pred)) return r; } - return nullptr; + return {}; } #endif // ABSTRACTMETALANG_HELPERS_H diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h index 3b444197c..1420dcbe9 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h @@ -18,10 +18,12 @@ struct UsingMember; using AbstractMetaFunctionPtr = QSharedPointer<AbstractMetaFunction>; using AbstractMetaFunctionCPtr = QSharedPointer<const AbstractMetaFunction>; +using AbstractMetaClassPtr = QSharedPointer<AbstractMetaClass>; +using AbstractMetaClassCPtr = QSharedPointer<const AbstractMetaClass>; using AbstractMetaArgumentList = QList<AbstractMetaArgument>; -using AbstractMetaClassList = QList<AbstractMetaClass *>; -using AbstractMetaClassCList = QList<const AbstractMetaClass *>; +using AbstractMetaClassList = QList<AbstractMetaClassPtr>; +using AbstractMetaClassCList = QList<AbstractMetaClassCPtr>; using AbstractMetaEnumList = QList<AbstractMetaEnum>; using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>; using AbstractMetaFieldList = QList<AbstractMetaField>; diff --git a/sources/shiboken6/ApiExtractor/abstractmetatype.cpp b/sources/shiboken6/ApiExtractor/abstractmetatype.cpp index 19e030330..fa3ff7a1a 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetatype.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetatype.cpp @@ -927,7 +927,7 @@ AbstractMetaType AbstractMetaType::fromTypeEntry(const TypeEntryCPtr &typeEntry) return metaType; } -AbstractMetaType AbstractMetaType::fromAbstractMetaClass(const AbstractMetaClass *metaClass) +AbstractMetaType AbstractMetaType::fromAbstractMetaClass(const AbstractMetaClassCPtr &metaClass) { return fromTypeEntry(metaClass->typeEntry()); } diff --git a/sources/shiboken6/ApiExtractor/abstractmetatype.h b/sources/shiboken6/ApiExtractor/abstractmetatype.h index 237c33d20..c7052cafb 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetatype.h +++ b/sources/shiboken6/ApiExtractor/abstractmetatype.h @@ -186,7 +186,7 @@ public: /// Creates an AbstractMetaType object from a TypeEntry. static AbstractMetaType fromTypeEntry(const TypeEntryCPtr &typeEntry); /// Creates an AbstractMetaType object from an AbstractMetaClass. - static AbstractMetaType fromAbstractMetaClass(const AbstractMetaClass *metaClass); + static AbstractMetaType fromAbstractMetaClass(const AbstractMetaClassCPtr &metaClass); static void dereference(QString *type); // "foo" -> "(*foo)" /// Apply the result of shouldDereferenceArgument() diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp index 2e22f21e3..b107dec02 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.cpp +++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp @@ -54,7 +54,7 @@ struct ApiExtractorPrivate void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context, const AbstractMetaFunctionCPtr &func); void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); void collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context); void collectInstantiatedOpqaqueContainers(InstantiationCollectContext &context); void collectContainerTypesFromSnippets(InstantiationCollectContext &context); @@ -303,7 +303,6 @@ std::optional<ApiExtractorResult> ApiExtractor::run(ApiExtractorFlags flags) auto *data = new ApiExtractorResultData; classListToCList(d->m_builder->takeClasses(), &data->m_metaClasses); - classListToCList(d->m_builder->takeTemplates(), &data->m_templates); classListToCList(d->m_builder->takeSmartPointers(), &data->m_smartPointers); data->m_globalFunctions = d->m_builder->globalFunctions(); data->m_globalEnums = d->m_builder->globalEnums(); @@ -349,15 +348,15 @@ AbstractMetaFunctionPtr AbstractMetaFunctionPtr ApiExtractor::inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass) + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass) { return AbstractMetaBuilder::inheritTemplateMember(function, templateTypes, templateClass, subclass); } -AbstractMetaClass *ApiExtractor::inheritTemplateClass(const ComplexTypeEntryPtr &te, - const AbstractMetaClass *templateClass, +AbstractMetaClassPtr ApiExtractor::inheritTemplateClass(const ComplexTypeEntryPtr &te, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags) { @@ -532,9 +531,9 @@ void ApiExtractorPrivate::addInstantiatedSmartPointer(InstantiationCollectContex {instantiatedType}, flags); Q_ASSERT(smp.specialized); if (withinNameSpace) { // move class to desired namespace - auto *enclClass = AbstractMetaClass::findClass(m_builder->classes(), parentTypeEntry); - Q_ASSERT(enclClass); - auto *specialized = const_cast<AbstractMetaClass *>(smp.specialized); + const auto enclClass = AbstractMetaClass::findClass(m_builder->classes(), parentTypeEntry); + Q_ASSERT(!enclClass.isNull()); + auto specialized = qSharedPointerConstCast<AbstractMetaClass>(smp.specialized); specialized->setEnclosingClass(enclClass); enclClass->addInnerClass(specialized); } @@ -562,7 +561,7 @@ ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(Instantiation void ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(InstantiationCollectContext &context, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { if (!metaClass->typeEntry()->generateCode()) return; @@ -575,7 +574,7 @@ ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(Instantiation // instantiations are specified to be in namespaces. auto &innerClasses = metaClass->innerClasses(); for (auto i = innerClasses.size() - 1; i >= 0; --i) { - auto *innerClass = innerClasses.at(i); + const auto &innerClass = innerClasses.at(i); if (!innerClass->typeEntry()->isSmartPointer()) collectInstantiatedContainersAndSmartPointers(context, innerClass); } @@ -587,7 +586,7 @@ ApiExtractorPrivate::collectInstantiatedContainersAndSmartPointers(Instantiation collectInstantiatedOpqaqueContainers(context); for (const auto &func : m_builder->globalFunctions()) collectInstantiatedContainersAndSmartPointers(context, func); - for (auto metaClass : m_builder->classes()) + for (const auto &metaClass : m_builder->classes()) collectInstantiatedContainersAndSmartPointers(context, metaClass); collectContainerTypesFromSnippets(context); } diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h index 51df5e45a..011a6dd3d 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.h +++ b/sources/shiboken6/ApiExtractor/apiextractor.h @@ -74,13 +74,13 @@ public: static AbstractMetaFunctionPtr inheritTemplateMember(const AbstractMetaFunctionCPtr &function, const AbstractMetaTypeList &templateTypes, - const AbstractMetaClass *templateClass, - AbstractMetaClass *subclass); + const AbstractMetaClassCPtr &templateClass, + const AbstractMetaClassPtr &subclass); /// Forwards to AbstractMetaBuilder::inheritTemplateClass() - static AbstractMetaClass * + static AbstractMetaClassPtr inheritTemplateClass(const ComplexTypeEntryPtr &te, - const AbstractMetaClass *templateClass, + const AbstractMetaClassCPtr &templateClass, const AbstractMetaTypeList &templateTypes, InheritTemplateFlags flags = {}); diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.cpp b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp index a0917d64e..b1a386ea6 100644 --- a/sources/shiboken6/ApiExtractor/apiextractorresult.cpp +++ b/sources/shiboken6/ApiExtractor/apiextractorresult.cpp @@ -11,14 +11,7 @@ ApiExtractorResultData::ApiExtractorResultData() = default; -ApiExtractorResultData::~ApiExtractorResultData() -{ - qDeleteAll(m_smartPointers); - qDeleteAll(m_metaClasses); - qDeleteAll(m_templates); - for (auto &smp : m_instantiatedSmartPointers) - delete smp.specialized; -} +ApiExtractorResultData::~ApiExtractorResultData() = default; ApiExtractorResult::ApiExtractorResult() : d(new ApiExtractorResultData) { diff --git a/sources/shiboken6/ApiExtractor/apiextractorresult.h b/sources/shiboken6/ApiExtractor/apiextractorresult.h index f85fca9f0..1e1858c81 100644 --- a/sources/shiboken6/ApiExtractor/apiextractorresult.h +++ b/sources/shiboken6/ApiExtractor/apiextractorresult.h @@ -17,8 +17,8 @@ class ApiExtractorResultData; struct InstantiatedSmartPointer { - const AbstractMetaClass *smartPointer = nullptr; // Template class - const AbstractMetaClass *specialized = nullptr; // Specialized for type + AbstractMetaClassCPtr smartPointer; // Template class + AbstractMetaClassCPtr specialized; // Specialized for type AbstractMetaType type; }; diff --git a/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h b/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h index 05d548d6d..ba48bf41b 100644 --- a/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h +++ b/sources/shiboken6/ApiExtractor/apiextractorresultdata_p.h @@ -16,7 +16,6 @@ public: ~ApiExtractorResultData(); AbstractMetaClassCList m_metaClasses; - AbstractMetaClassCList m_templates; // not exposed, just for ownership AbstractMetaClassCList m_smartPointers; AbstractMetaFunctionCList m_globalFunctions; AbstractMetaEnumList m_globalEnums; diff --git a/sources/shiboken6/ApiExtractor/dependency.h b/sources/shiboken6/ApiExtractor/dependency.h index f0e525e26..aa280de03 100644 --- a/sources/shiboken6/ApiExtractor/dependency.h +++ b/sources/shiboken6/ApiExtractor/dependency.h @@ -13,8 +13,8 @@ class AbstractMetaClass; struct Dependency { - AbstractMetaClass *parent; - AbstractMetaClass *child; + AbstractMetaClassPtr parent; + AbstractMetaClassPtr child; }; using Dependencies = QList<Dependency>; diff --git a/sources/shiboken6/ApiExtractor/docparser.cpp b/sources/shiboken6/ApiExtractor/docparser.cpp index 908e8576b..137313cef 100644 --- a/sources/shiboken6/ApiExtractor/docparser.cpp +++ b/sources/shiboken6/ApiExtractor/docparser.cpp @@ -86,7 +86,7 @@ bool DocParser::skipForQuery(const AbstractMetaFunctionCPtr &func) usesRValueReference); } -DocModificationList DocParser::getDocModifications(const AbstractMetaClass *cppClass, +DocModificationList DocParser::getDocModifications(const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func) { auto te = cppClass->typeEntry(); @@ -120,7 +120,7 @@ QString DocParser::enumBaseClass(const AbstractMetaEnum &e) return e.typeEntry()->flags() != nullptr ? u"Flag"_s : u"Enum"_s; } -AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClass *metaClass) +AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClassCPtr &metaClass) { auto result = metaClass->functionsInTargetLang(); for (auto i = result.size() - 1; i >= 0; --i) { diff --git a/sources/shiboken6/ApiExtractor/docparser.h b/sources/shiboken6/ApiExtractor/docparser.h index 88643b7bf..d037fc4e4 100644 --- a/sources/shiboken6/ApiExtractor/docparser.h +++ b/sources/shiboken6/ApiExtractor/docparser.h @@ -26,7 +26,7 @@ public: DocParser(); virtual ~DocParser(); - virtual void fillDocumentation(AbstractMetaClass *metaClass) = 0; + virtual void fillDocumentation(const AbstractMetaClassPtr &metaClass) = 0; /** * Process and retrieves documentation concerning the entire @@ -93,7 +93,7 @@ public: /// Helper to return the documentation modifications for a class /// or a member function. - static DocModificationList getDocModifications(const AbstractMetaClass *cppClass, + static DocModificationList getDocModifications(const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func = {}); static QString enumBaseClass(const AbstractMetaEnum &e); @@ -103,7 +103,7 @@ protected: const QString &query, const DocModificationList &mods); - static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClass *metaClass); + static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClassCPtr &metaClass); static QString applyDocModifications(const DocModificationList &mods, const QString &xml); diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp index 8f608cbc8..230b73fcf 100644 --- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp +++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp @@ -41,7 +41,7 @@ Documentation DoxygenParser::retrieveModuleDocumentation() return retrieveModuleDocumentation(packageName()); } -void DoxygenParser::fillDocumentation(AbstractMetaClass *metaClass) +void DoxygenParser::fillDocumentation(const AbstractMetaClassPtr &metaClass) { if (!metaClass) return; diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.h b/sources/shiboken6/ApiExtractor/doxygenparser.h index ea1883d12..4f6a9e53c 100644 --- a/sources/shiboken6/ApiExtractor/doxygenparser.h +++ b/sources/shiboken6/ApiExtractor/doxygenparser.h @@ -10,7 +10,7 @@ class DoxygenParser : public DocParser { public: DoxygenParser() = default; - void fillDocumentation(AbstractMetaClass *metaClass) override; + void fillDocumentation(const AbstractMetaClassPtr &metaClass) override; Documentation retrieveModuleDocumentation() override; Documentation retrieveModuleDocumentation(const QString& name) override; }; diff --git a/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp b/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp index f2d5074b7..05883e0cf 100644 --- a/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp +++ b/sources/shiboken6/ApiExtractor/enclosingclassmixin.cpp @@ -5,9 +5,9 @@ #include "abstractmetalang.h" #include "namespacetypeentry.h" -const AbstractMetaClass *EnclosingClassMixin::targetLangEnclosingClass() const +AbstractMetaClassCPtr EnclosingClassMixin::targetLangEnclosingClass() const { - auto result = m_enclosingClass; + auto result = m_enclosingClass.toStrongRef(); while (result && !NamespaceTypeEntry::isVisibleScope(result->typeEntry())) result = result->enclosingClass(); return result; diff --git a/sources/shiboken6/ApiExtractor/enclosingclassmixin.h b/sources/shiboken6/ApiExtractor/enclosingclassmixin.h index 31aeb9285..0fe8445ac 100644 --- a/sources/shiboken6/ApiExtractor/enclosingclassmixin.h +++ b/sources/shiboken6/ApiExtractor/enclosingclassmixin.h @@ -4,16 +4,21 @@ #ifndef ENCLOSINGCLASSMIXIN_H #define ENCLOSINGCLASSMIXIN_H +#include "abstractmetalang_typedefs.h" + class AbstractMetaClass; class EnclosingClassMixin { public: - const AbstractMetaClass *enclosingClass() const { return m_enclosingClass; } - void setEnclosingClass(const AbstractMetaClass *cls) { m_enclosingClass = cls; } - const AbstractMetaClass *targetLangEnclosingClass() const; + + const AbstractMetaClassCPtr enclosingClass() const + { return m_enclosingClass.toStrongRef(); } + void setEnclosingClass(const AbstractMetaClassCPtr &cls) + { m_enclosingClass = cls.toWeakRef(); } + AbstractMetaClassCPtr targetLangEnclosingClass() const; private: - const AbstractMetaClass *m_enclosingClass = nullptr; + QWeakPointer<const AbstractMetaClass> m_enclosingClass; }; #endif // ENCLOSINGCLASSMIXIN_H diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp index 247bb7db0..83bd2c380 100644 --- a/sources/shiboken6/ApiExtractor/messages.cpp +++ b/sources/shiboken6/ApiExtractor/messages.cpp @@ -29,7 +29,7 @@ static inline QString colonColon() { return QStringLiteral("::"); } // abstractmetabuilder.cpp -QString msgNoFunctionForModification(const AbstractMetaClass *klass, +QString msgNoFunctionForModification(const AbstractMetaClassCPtr &klass, const QString &signature, const QString &originalSignature, const QStringList &possibleSignatures, @@ -79,7 +79,7 @@ QString msgTypeModificationFailed(const QString &type, int n, str << "type of argument " << n; str << " of "; - if (auto *c = func->ownerClass()) + if (auto c = func->ownerClass(); !c.isNull()) str << c->name() << "::"; str << func->signature() << " to \"" << type << "\": " << why; return result; @@ -113,7 +113,7 @@ QString msgArgumentRemovalFailed(const AbstractMetaFunction *func, int n, QString result; QTextStream str(&result); str << "Unable to remove argument " << n << " of "; - if (auto *c = func->ownerClass()) + if (auto c = func->ownerClass(); !c.isNull()) str << c->name() << "::"; str << func->signature() << ": " << why; return result; @@ -157,7 +157,7 @@ static void msgFormatEnumType(Stream &str, } static void formatAddedFuncError(const QString &addedFuncName, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, QTextStream &str) { if (context) { @@ -173,7 +173,7 @@ static void formatAddedFuncError(const QString &addedFuncName, QString msgAddedFunctionInvalidArgType(const QString &addedFuncName, const QStringList &typeName, int pos, const QString &why, - const AbstractMetaClass *context) + const AbstractMetaClassCPtr &context) { QString result; QTextStream str(&result); @@ -186,7 +186,7 @@ QString msgAddedFunctionInvalidArgType(const QString &addedFuncName, QString msgAddedFunctionInvalidReturnType(const QString &addedFuncName, const QStringList &typeName, const QString &why, - const AbstractMetaClass *context) + const AbstractMetaClassCPtr &context) { QString result; QTextStream str(&result); @@ -197,7 +197,7 @@ QString msgAddedFunctionInvalidReturnType(const QString &addedFuncName, return result; } -QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClass *context, +QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClassCPtr &context, int n, const QString &className, const AbstractMetaFunction *f) { @@ -324,7 +324,7 @@ QString msgShadowingFunction(const AbstractMetaFunction *f1, return result; } -QString msgSignalOverloaded(const AbstractMetaClass *c, +QString msgSignalOverloaded(const AbstractMetaClassCPtr &c, const AbstractMetaFunction *f) { QString result; @@ -392,7 +392,7 @@ QString msgEnumNotDefined(const EnumTypeEntryCPtr &t) return result; } -QString msgUnknownBase(const AbstractMetaClass *metaClass, +QString msgUnknownBase(const AbstractMetaClassCPtr &metaClass, const QString &baseClassName) { QString result; @@ -402,7 +402,7 @@ QString msgUnknownBase(const AbstractMetaClass *metaClass, return result; } -QString msgBaseNotInTypeSystem(const AbstractMetaClass *metaClass, +QString msgBaseNotInTypeSystem(const AbstractMetaClassCPtr &metaClass, const QString &baseClassName) { QString result; @@ -511,7 +511,7 @@ QString msgPropertyExists(const QString &className, const QString &name) + name + u"\" (defined by Q_PROPERTY)."_s; } -QString msgFunctionVisibilityModified(const AbstractMetaClass *c, +QString msgFunctionVisibilityModified(const AbstractMetaClassCPtr &c, const AbstractMetaFunction *f) { QString result; @@ -521,7 +521,7 @@ QString msgFunctionVisibilityModified(const AbstractMetaClass *c, return result; } -QString msgUsingMemberClassNotFound(const AbstractMetaClass *c, +QString msgUsingMemberClassNotFound(const AbstractMetaClassCPtr &c, const QString &baseClassName, const QString &memberName) { @@ -587,7 +587,7 @@ QString msgFallbackForDocumentation(const QString &fileName, } QString msgCannotFindDocumentation(const QString &fileName, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaEnum &e, const QString &query) { @@ -597,7 +597,7 @@ QString msgCannotFindDocumentation(const QString &fileName, } QString msgCannotFindDocumentation(const QString &fileName, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaField &f, const QString &query) { @@ -688,7 +688,7 @@ QString msgCannotFindSmartPointerMethod(const SmartPointerTypeEntryCPtr &te, con + te->name() + u"\" not found."_s; } -QString msgMethodNotFound(const AbstractMetaClass *klass, const QString &name) +QString msgMethodNotFound(const AbstractMetaClassCPtr &klass, const QString &name) { return u"Method \""_s + name + u"\" not found in class "_s + klass->name() + u'.'; @@ -734,7 +734,7 @@ QString msgCyclicDependency(const QString &funcName, const QString &graphName, if (i) str << ", \""; str << involvedConversions.at(i)->signature() << '"'; - if (const AbstractMetaClass *c = involvedConversions.at(i)->implementingClass()) + if (const auto c = involvedConversions.at(i)->implementingClass(); !c.isNull()) str << '(' << c->name() << ')'; } } @@ -763,7 +763,7 @@ QString msgUnknownOperator(const AbstractMetaFunction *func) { QString result = u"Unknown operator: \""_s + func->originalName() + u'"'; - if (const AbstractMetaClass *c = func->implementingClass()) + if (const auto c = func->implementingClass(); !c.isNull()) result += u" in class: "_s + c->name(); return result; } @@ -774,7 +774,7 @@ QString msgWrongIndex(const char *varName, const QString &capture, QString result; QTextStream str(&result); str << "Wrong index for " << varName << " variable (" << capture << ") on "; - if (const AbstractMetaClass *c = func->implementingClass()) + if (const auto c = func->implementingClass(); !c.isNull()) str << c->name() << "::"; str << func->signature(); return result; diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h index 17255f717..2253034f6 100644 --- a/sources/shiboken6/ApiExtractor/messages.h +++ b/sources/shiboken6/ApiExtractor/messages.h @@ -25,19 +25,19 @@ QT_FORWARD_DECLARE_CLASS(QXmlStreamReader) QString msgAddedFunctionInvalidArgType(const QString &addedFuncName, const QStringList &typeName, int pos, const QString &why, - const AbstractMetaClass *context = nullptr); + const AbstractMetaClassCPtr &context = {}); QString msgAddedFunctionInvalidReturnType(const QString &addedFuncName, const QStringList &typeName, const QString &why, - const AbstractMetaClass *context = nullptr); + const AbstractMetaClassCPtr &context = {}); -QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClass *context, +QString msgUnnamedArgumentDefaultExpression(const AbstractMetaClassCPtr &context, int n, const QString &className, const AbstractMetaFunction *f); QString msgArgumentIndexOutOfRange(const AbstractMetaFunction *func, int index); -QString msgNoFunctionForModification(const AbstractMetaClass *klass, +QString msgNoFunctionForModification(const AbstractMetaClassCPtr &klass, const QString &signature, const QString &originalSignature, const QStringList &possibleSignatures, @@ -82,7 +82,7 @@ QString msgUnmatchedReturnType(const FunctionModelItem &functionItem, QString msgShadowingFunction(const AbstractMetaFunction *f1, const AbstractMetaFunction *f2); -QString msgSignalOverloaded(const AbstractMetaClass *c, +QString msgSignalOverloaded(const AbstractMetaClassCPtr &c, const AbstractMetaFunction *f); QString msgSkippingFunction(const FunctionModelItem &functionItem, @@ -103,10 +103,10 @@ QString msgStrippingArgument(const FunctionModelItem &f, int i, QString msgEnumNotDefined(const EnumTypeEntryCPtr &t); -QString msgUnknownBase(const AbstractMetaClass *metaClass, +QString msgUnknownBase(const AbstractMetaClassCPtr &metaClass, const QString &baseClassName); -QString msgBaseNotInTypeSystem(const AbstractMetaClass *metaClass, +QString msgBaseNotInTypeSystem(const AbstractMetaClassCPtr &metaClass, const QString &baseClassName); QString msgArrayModificationFailed(const FunctionModelItem &functionItem, @@ -140,10 +140,10 @@ QString msgPropertyTypeParsingFailed(const QString &name, const QString &typeNam const QString &why); QString msgPropertyExists(const QString &className, const QString &name); -QString msgFunctionVisibilityModified(const AbstractMetaClass *c, +QString msgFunctionVisibilityModified(const AbstractMetaClassCPtr &c, const AbstractMetaFunction *f); -QString msgUsingMemberClassNotFound(const AbstractMetaClass *c, +QString msgUsingMemberClassNotFound(const AbstractMetaClassCPtr &c, const QString &baseClassName, const QString &memberName); @@ -164,12 +164,12 @@ QString msgFallbackForDocumentation(const QString &fileName, const QString &query = {}); QString msgCannotFindDocumentation(const QString &fileName, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaEnum &e, const QString &query = {}); QString msgCannotFindDocumentation(const QString &fileName, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaField &f, const QString &query); @@ -190,7 +190,7 @@ QString msgCannotFindSmartPointerGetter(const SmartPointerTypeEntryCPtr &); QString msgCannotFindSmartPointerMethod(const SmartPointerTypeEntryCPtr &te, const QString &m); -QString msgMethodNotFound(const AbstractMetaClass *klass, const QString &name); +QString msgMethodNotFound(const AbstractMetaClassCPtr &klass, const QString &name); QString msgLeftOverArguments(const QVariantMap &remainingArgs); diff --git a/sources/shiboken6/ApiExtractor/propertyspec.cpp b/sources/shiboken6/ApiExtractor/propertyspec.cpp index 1c86cacf6..4f89bd486 100644 --- a/sources/shiboken6/ApiExtractor/propertyspec.cpp +++ b/sources/shiboken6/ApiExtractor/propertyspec.cpp @@ -269,7 +269,7 @@ TypeSystemProperty QPropertySpec::typeSystemPropertyFromQ_Property(const QString // the AbstractMetaType from the type string. std::optional<QPropertySpec> QPropertySpec::fromTypeSystemProperty(AbstractMetaBuilderPrivate *b, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, const TypeSystemProperty &ts, const QStringList &scopes, QString *errorMessage) @@ -302,7 +302,7 @@ std::optional<QPropertySpec> // via TypeSystemProperty. std::optional<QPropertySpec> QPropertySpec::parseQ_Property(AbstractMetaBuilderPrivate *b, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, const QString &declarationIn, const QStringList &scopes, QString *errorMessage) diff --git a/sources/shiboken6/ApiExtractor/propertyspec.h b/sources/shiboken6/ApiExtractor/propertyspec.h index 907668cb1..e27b53bd1 100644 --- a/sources/shiboken6/ApiExtractor/propertyspec.h +++ b/sources/shiboken6/ApiExtractor/propertyspec.h @@ -6,6 +6,7 @@ class AbstractMetaType; +#include "abstractmetalang_typedefs.h" #include "typesystem_typedefs.h" #include <QtCore/QStringList> @@ -42,14 +43,14 @@ public: static std::optional<QPropertySpec> fromTypeSystemProperty(AbstractMetaBuilderPrivate *b, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, const TypeSystemProperty &ts, const QStringList &scopes, QString *errorMessage); static std::optional<QPropertySpec> parseQ_Property(AbstractMetaBuilderPrivate *b, - AbstractMetaClass *metaClass, + const AbstractMetaClassPtr &metaClass, const QString &declarationIn, const QStringList &scopes, QString *errorMessage); diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp index 8daf1ad85..9c375edc6 100644 --- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp +++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp @@ -102,7 +102,7 @@ static QString formatFunctionArgTypeQuery(const AbstractMetaType &metaType) QString QtDocParser::functionDocumentation(const QString &sourceFileName, const ClassDocumentation &classDocumentation, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaFunctionCPtr &func, QString *errorMessage) { @@ -119,7 +119,7 @@ QString QtDocParser::functionDocumentation(const QString &sourceFileName, QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName, const ClassDocumentation &classDocumentation, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaFunctionCPtr &func, QString *errorMessage) { @@ -202,14 +202,14 @@ static QString extractBrief(QString *value) return briefValue; } -void QtDocParser::fillDocumentation(AbstractMetaClass *metaClass) +void QtDocParser::fillDocumentation(const AbstractMetaClassPtr &metaClass) { - if (!metaClass) + if (metaClass.isNull()) return; - auto *context = metaClass->enclosingClass(); - while(context) { - if (context->enclosingClass() == nullptr) + auto context = metaClass->enclosingClass(); + while (!context.isNull()) { + if (context->enclosingClass().isNull()) break; context = context->enclosingClass(); } diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.h b/sources/shiboken6/ApiExtractor/qtdocparser.h index 402664217..2ad941971 100644 --- a/sources/shiboken6/ApiExtractor/qtdocparser.h +++ b/sources/shiboken6/ApiExtractor/qtdocparser.h @@ -12,20 +12,20 @@ class QtDocParser : public DocParser { public: QtDocParser() = default; - void fillDocumentation(AbstractMetaClass *metaClass) override; + void fillDocumentation(const AbstractMetaClassPtr &metaClass) override; Documentation retrieveModuleDocumentation() override; Documentation retrieveModuleDocumentation(const QString& name) override; private: static QString functionDocumentation(const QString &sourceFileName, const ClassDocumentation &classDocumentation, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaFunctionCPtr &func, QString *errorMessage); static QString queryFunctionDocumentation(const QString &sourceFileName, const ClassDocumentation &classDocumentation, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const AbstractMetaFunctionCPtr &func, QString *errorMessage); }; diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp index 8021810b3..6f96f6de5 100644 --- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp @@ -71,7 +71,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace() // QVERIFY(classes[0]->hasNonPrivateConstructor()); } -static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClass *c) +static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClassCPtr &c) { AbstractMetaFunctionCList result; const auto &functions = c->functions(); @@ -113,11 +113,11 @@ public: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 4); - auto *a = AbstractMetaClass::findClass(classes, u"A"); - auto *b = AbstractMetaClass::findClass(classes, u"B"); - auto *c = AbstractMetaClass::findClass(classes, u"C"); - const AbstractMetaClass *f = AbstractMetaClass::findClass(classes, u"F"); - QVERIFY(f); + const auto a = AbstractMetaClass::findClass(classes, u"A"); + const auto b = AbstractMetaClass::findClass(classes, u"B"); + const auto c = AbstractMetaClass::findClass(classes, u"C"); + const auto f = AbstractMetaClass::findClass(classes, u"F"); + QVERIFY(!f.isNull()); QCOMPARE(a->baseClass(), nullptr); QCOMPARE(b->baseClass(), a); @@ -196,10 +196,10 @@ class Derived : public Base {}; QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto base = AbstractMetaClass::findClass(classes, u"Base"); - QVERIFY(base); + const auto base = AbstractMetaClass::findClass(classes, u"Base"); + QVERIFY(!base.isNull()); QVERIFY(base->isPolymorphic()); - auto derived = AbstractMetaClass::findClass(classes, u"Derived"); + const auto derived = AbstractMetaClass::findClass(classes, u"Derived"); QVERIFY(derived); QVERIFY(derived->isPolymorphic()); } @@ -221,7 +221,7 @@ void TestAbstractMetaClass::testDefaultValues() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); const auto candidates = classA->queryFunctionsByName(u"method"_s); QCOMPARE(candidates.size(), 1); const auto &method = candidates.constFirst(); @@ -251,7 +251,7 @@ void TestAbstractMetaClass::testModifiedDefaultValues() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); const auto methodMatches = classA->queryFunctionsByName(u"method"_s); QCOMPARE(methodMatches.size(), 1); const auto method = methodMatches.constFirst(); @@ -277,11 +277,11 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QVERIFY(classA->isPolymorphic()); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"A::B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"A::B"); + QVERIFY(!classB.isNull()); QVERIFY(!classB->isPolymorphic()); } @@ -305,10 +305,10 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"A::B"); - QVERIFY(classB); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); + const auto classB = AbstractMetaClass::findClass(classes, u"A::B"); + QVERIFY(!classB.isNull()); const auto fooF = classB->findFunction(u"foo"); QVERIFY(!fooF.isNull()); } @@ -337,8 +337,8 @@ void TestAbstractMetaClass::testSpecialFunctions() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor); QCOMPARE(ctors.size(), 2); QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction); @@ -348,8 +348,8 @@ void TestAbstractMetaClass::testSpecialFunctions() QCOMPARE(assigmentOps.constFirst()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); ctors = classB->queryFunctions(FunctionQueryOption::AnyConstructor); QCOMPARE(ctors.size(), 2); QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction); @@ -403,7 +403,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 6); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QVERIFY(classA); QCOMPARE(classA->functions().size(), 2); @@ -417,29 +417,29 @@ void TestAbstractMetaClass::testClassDefaultConstructors() QCOMPARE(ctors[1]->arguments().size(), 1); QCOMPARE(ctors[1]->minimalSignature(), u"A(A)"); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); QCOMPARE(classB->functions().size(), 2); QCOMPARE(classB->functions().constFirst()->minimalSignature(), u"B()"); - auto *classC = AbstractMetaClass::findClass(classes, u"C"); - QVERIFY(classC); + const auto classC = AbstractMetaClass::findClass(classes, u"C"); + QVERIFY(!classC.isNull()); QCOMPARE(classC->functions().size(), 1); QCOMPARE(classC->functions().constFirst()->minimalSignature(), u"C(C)"); - auto *classD = AbstractMetaClass::findClass(classes, u"D"); - QVERIFY(classD); + const auto classD = AbstractMetaClass::findClass(classes, u"D"); + QVERIFY(!classD.isNull()); QCOMPARE(classD->functions().size(), 1); QCOMPARE(classD->functions().constFirst()->minimalSignature(), u"D(D)"); QVERIFY(classD->functions().constFirst()->isPrivate()); - auto *classE = AbstractMetaClass::findClass(classes, u"E"); - QVERIFY(classE); + const auto classE = AbstractMetaClass::findClass(classes, u"E"); + QVERIFY(!classE.isNull()); QVERIFY(classE->hasPrivateDestructor()); QCOMPARE(classE->functions().size(), 0); - auto *classF = AbstractMetaClass::findClass(classes, u"F"); - QVERIFY(classF); + const auto classF = AbstractMetaClass::findClass(classes, u"F"); + QVERIFY(!classF.isNull()); ctors = classF->queryFunctions(FunctionQueryOption::AnyConstructor); QCOMPARE(ctors.size(), 2); @@ -471,7 +471,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QVERIFY(classA); auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor); @@ -485,8 +485,8 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors() QCOMPARE(ctors[1]->minimalSignature(), u"A(A)"); QVERIFY(ctors[1]->isPrivate()); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); ctors = classB->queryFunctions(FunctionQueryOption::Constructors); QCOMPARE(ctors.size(), 1); @@ -509,8 +509,8 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors); QCOMPARE(ctors.size(), 1); @@ -530,8 +530,8 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors); QCOMPARE(ctors.size(), 1); @@ -566,10 +566,10 @@ void TestAbstractMetaClass::testIsPolymorphic() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *b = AbstractMetaClass::findClass(classes, u"A"); + const auto b = AbstractMetaClass::findClass(classes, u"A"); QVERIFY(!b->isPolymorphic()); - auto *a = AbstractMetaClass::findClass(classes, u"B"); + const auto a = AbstractMetaClass::findClass(classes, u"B"); QVERIFY(!a->isPolymorphic()); } @@ -596,10 +596,10 @@ class Derived : public BaseAlias2 { QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto base = AbstractMetaClass::findClass(classes, u"Base"); - QVERIFY(base); - auto derived = AbstractMetaClass::findClass(classes, u"Derived"); - QVERIFY(derived); + const auto base = AbstractMetaClass::findClass(classes, u"Base"); + QVERIFY(!base.isNull()); + const auto derived = AbstractMetaClass::findClass(classes, u"Derived"); + QVERIFY(!derived.isNull()); QCOMPARE(derived->baseClasses().value(0), base); } @@ -681,10 +681,10 @@ public: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto base = AbstractMetaClass::findClass(classes, u"Base"); - QVERIFY(base); - auto derived = AbstractMetaClass::findClass(classes, u"Derived"); - QVERIFY(derived); + const auto base = AbstractMetaClass::findClass(classes, u"Base"); + QVERIFY(!base.isNull()); + const auto derived = AbstractMetaClass::findClass(classes, u"Derived"); + QVERIFY(!derived.isNull()); const auto usingMembers = derived->usingMembers(); QCOMPARE(usingMembers.size(), 2); for (const auto &um : usingMembers) { @@ -735,8 +735,8 @@ void TestAbstractMetaClass::testUsingTemplateMembers() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto valueList = AbstractMetaClass::findClass(classes, u"ValueList"); - QVERIFY(valueList); + const auto valueList = AbstractMetaClass::findClass(classes, u"ValueList"); + QVERIFY(!valueList.isNull()); auto list = valueList->templateBaseClass(); QVERIFY(valueList->isUsingMember(list, u"append"_s, Access::Public)); QCOMPARE(valueList->queryFunctionsByName(u"append"_s).size(), 2); @@ -765,7 +765,7 @@ public: QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *tc = AbstractMetaClass::findClass(classes, u"TestClass"); + const auto tc = AbstractMetaClass::findClass(classes, u"TestClass"); // Verify that the constructor and 2 functions are generated. const auto &functions = tc->functions(); QCOMPARE(functions.size(), 5); diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp index 072764155..2c6cb5324 100644 --- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp @@ -161,8 +161,8 @@ void TestAbstractMetaType::testTypedef() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - const AbstractMetaClass *c = AbstractMetaClass::findClass(classes, u"C"); - QVERIFY(c); + const auto c = AbstractMetaClass::findClass(classes, u"C"); + QVERIFY(!c.isNull()); QVERIFY(c->isTypeDef()); } @@ -211,8 +211,8 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto overloads = classA->queryFunctionsByName(u"method"_s); QCOMPARE(overloads.size(), 1); const auto method = overloads.constFirst(); diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp index 72cf34693..883cc62e0 100644 --- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp @@ -105,8 +105,8 @@ struct A { QVERIFY(!builder.isNull()); auto *typeDb = TypeDatabase::instance(); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); // default ctor, default copy ctor, func a() and the added functions QCOMPARE(classA->functions().size(), 5); @@ -148,8 +148,8 @@ void TestAddFunction::testAddFunctionConstructor() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->functions().size(), 3); // default and added ctors const auto addedFunc = classA->functions().constLast(); QCOMPARE(addedFunc->access(), Access::Public); @@ -171,8 +171,8 @@ void TestAddFunction::testAddFunctionTagDefaultValues() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); // default ctor, default copy ctor and the added function QCOMPARE(classA->functions().size(), 3); const auto addedFunc = classA->functions().constLast(); @@ -197,8 +197,8 @@ void TestAddFunction::testAddFunctionCodeSnippets() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->functions().constLast(); QVERIFY(addedFunc->hasInjectedCode()); } @@ -227,8 +227,8 @@ void TestAddFunction::testAddFunctionWithoutParenteses() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"func"); QVERIFY(!addedFunc.isNull()); QVERIFY(addedFunc->hasInjectedCode()); @@ -264,8 +264,8 @@ void TestAddFunction::testAddFunctionWithDefaultArgs() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"func"); QVERIFY(!addedFunc.isNull()); const AbstractMetaArgument &arg = addedFunc->arguments().at(1); @@ -287,8 +287,8 @@ void TestAddFunction::testAddFunctionAtModuleLevel() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); auto *typeDb = TypeDatabase::instance(); @@ -328,8 +328,8 @@ void TestAddFunction::testAddFunctionWithVarargs() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"func"); QVERIFY(!addedFunc.isNull()); const AbstractMetaArgument &arg = addedFunc->arguments().constLast(); @@ -352,8 +352,8 @@ void TestAddFunction::testAddStaticFunction() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"func"); QVERIFY(!addedFunc.isNull()); QVERIFY(addedFunc->isStatic()); @@ -378,7 +378,7 @@ void TestAddFunction::testAddGlobalFunction() QVERIFY(!builder.isNull()); const auto globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.size(), 2); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), u"B"); + const auto classB = AbstractMetaClass::findClass(builder->classes(), u"B"); QVERIFY(classB); QVERIFY(!classB->findFunction(u"globalFunc")); QVERIFY(!classB->findFunction(u"globalFunc2")); @@ -426,7 +426,7 @@ void TestAddFunction::testModifyAddedFunction() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *foo = AbstractMetaClass::findClass(classes, u"Foo"); + const auto foo = AbstractMetaClass::findClass(classes, u"Foo"); const auto method = foo->findFunction(u"method"); QVERIFY(!method.isNull()); QCOMPARE(method->arguments().size(), 2); @@ -453,8 +453,8 @@ void TestAddFunction::testAddFunctionOnTypedef() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *foo = AbstractMetaClass::findClass(classes, u"FooInt"); - QVERIFY(foo); + const auto foo = AbstractMetaClass::findClass(classes, u"FooInt"); + QVERIFY(!foo.isNull()); QVERIFY(foo->hasNonPrivateConstructor()); const auto &lst = foo->queryFunctions(FunctionQueryOption::AnyConstructor); for (const auto &f : lst) diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp index e7c3a0106..6b6f7e599 100644 --- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp @@ -34,8 +34,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg.type().isArray()); @@ -43,7 +43,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger() QCOMPARE(arg.type().arrayElementType()->name(), u"double"); } -static QString functionMinimalSignature(const AbstractMetaClass *c, const QString &name) +static QString functionMinimalSignature(const AbstractMetaClassCPtr &c, const QString &name) { const auto f = c->findFunction(name); return f.isNull() ? QString() : f->minimalSignature(); @@ -72,7 +72,7 @@ void TestArrayArgument::testArraySignature() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); QCOMPARE(functionMinimalSignature(classA, u"mi1"_s), u"mi1(int[5])"); QCOMPARE(functionMinimalSignature(classA, u"mi1c"_s), @@ -108,8 +108,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); auto someEnum = classA->findEnum(u"SomeEnum"_s); QVERIFY(someEnum.has_value()); @@ -139,8 +139,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); AbstractMetaEnum someEnum = builder->globalEnums().constFirst(); auto nvalues = someEnum.findEnumValue(u"NValues"); diff --git a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp index bb8c6882b..ed71e6d55 100644 --- a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp @@ -61,7 +61,7 @@ void TestCodeInjections::testReadFile() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().constData())); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QCOMPARE(classA->typeEntry()->codeSnips().size(), 1); QString code = classA->typeEntry()->codeSnips().constFirst().code(); QVERIFY(code.indexOf(expected) != -1); @@ -87,7 +87,7 @@ void TestCodeInjections::testInjectWithValidApiVersion() true, u"1.0"_s)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QCOMPARE(classA->typeEntry()->codeSnips().size(), 1); } @@ -108,7 +108,7 @@ void TestCodeInjections::testInjectWithInvalidApiVersion() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QCOMPARE(classA->typeEntry()->codeSnips().size(), 0); } diff --git a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp index 4f8dcd4b7..e266c146f 100644 --- a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp @@ -32,8 +32,8 @@ void TestContainer::testContainerType() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); //search for class A - auto *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); auto baseContainer = classA->typeEntry()->baseContainerType(); QVERIFY(baseContainer); QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(), @@ -65,8 +65,8 @@ void TestContainer::testListOfValueType() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->templateBaseClassInstantiations().size(), 1); const AbstractMetaType templateInstanceType = classA->templateBaseClassInstantiations().constFirst(); diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp index f7d4b0673..ac6cb0290 100644 --- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp @@ -35,12 +35,12 @@ void TestConversionOperator::testConversionOperator() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C"); - QVERIFY(classA); - QVERIFY(classB); - QVERIFY(classC); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classC = AbstractMetaClass::findClass(classes, u"C"); + QVERIFY(!classA.isNull()); + QVERIFY(!classB.isNull()); + QVERIFY(!classC.isNull()); QCOMPARE(classA->functions().size(), 2); QCOMPARE(classB->functions().size(), 3); QCOMPARE(classC->functions().size(), 3); @@ -73,8 +73,8 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->externalConversionOperators().size(), 0); } @@ -97,10 +97,10 @@ void TestConversionOperator::testRemovedConversionOperator() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classA); - QVERIFY(classB); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classA.isNull()); + QVERIFY(!classB.isNull()); QCOMPARE(classA->functions().size(), 2); QCOMPARE(classB->functions().size(), 3); QCOMPARE(classA->externalConversionOperators().size(), 0); @@ -123,10 +123,10 @@ void TestConversionOperator::testConversionOperatorReturningReference() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classA); - QVERIFY(classB); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classA.isNull()); + QVERIFY(!classB.isNull()); QCOMPARE(classA->functions().size(), 2); QCOMPARE(classB->functions().size(), 3); QCOMPARE(classA->externalConversionOperators().size(), 1); @@ -157,10 +157,10 @@ void TestConversionOperator::testConversionOperatorReturningConstReference() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classA); - QVERIFY(classB); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classA.isNull()); + QVERIFY(!classB.isNull()); QCOMPARE(classA->functions().size(), 2); QCOMPARE(classB->functions().size(), 3); QCOMPARE(classA->externalConversionOperators().size(), 1); diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp index 0f3edcfe5..5b25c685d 100644 --- a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp @@ -37,8 +37,8 @@ void TestConversionRuleTag::testConversionRuleTagWithFile() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().data())); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto typeEntry = classA->typeEntry(); QVERIFY(typeEntry->isValue()); auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry); @@ -154,8 +154,8 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\ QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); - auto *classA = AbstractMetaClass::findClass(builder->classes(), u"Date"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"Date"); + QVERIFY(!classA.isNull()); QVERIFY(classA->typeEntry()->isValue()); auto vte = qSharedPointerCast<const ValueTypeEntry>(classA->typeEntry()); diff --git a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp index 7579509ff..8b1b23a49 100644 --- a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp @@ -22,14 +22,14 @@ void TestCtorInformation::testCtorIsPrivate() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - auto *klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + auto klass = AbstractMetaClass::findClass(classes, u"Control"); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasNonPrivateConstructor()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasNonPrivateConstructor()); klass = AbstractMetaClass::findClass(classes, u"CtorLess"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasNonPrivateConstructor()); } @@ -48,9 +48,9 @@ void TestCtorInformation::testHasNonPrivateCtor() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - const AbstractMetaClass *base = AbstractMetaClass::findClass(classes, u"Base"); + const auto base = AbstractMetaClass::findClass(classes, u"Base"); QCOMPARE(base->hasNonPrivateConstructor(), true); - const AbstractMetaClass *derived = AbstractMetaClass::findClass(classes, u"Derived"); + const auto derived = AbstractMetaClass::findClass(classes, u"Derived"); QCOMPARE(derived->hasNonPrivateConstructor(), true); } diff --git a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp index 95b33243e..11b0f6b62 100644 --- a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp @@ -28,11 +28,11 @@ private: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + auto klass = AbstractMetaClass::findClass(classes, u"Control"); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasPrivateDestructor()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasPrivateDestructor()); } @@ -56,11 +56,11 @@ protected: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + auto klass = AbstractMetaClass::findClass(classes, u"Control"); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasProtectedDestructor()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasProtectedDestructor()); } @@ -84,11 +84,11 @@ protected: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + auto klass = AbstractMetaClass::findClass(classes, u"Control"); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasVirtualDestructor()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasVirtualDestructor()); } @@ -111,17 +111,17 @@ class Subject : public SubjectBase {}; QCOMPARE(classes.size(), 4); auto klass = AbstractMetaClass::findClass(classes, u"ControlBase"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasVirtualDestructor()); klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(!klass->hasVirtualDestructor()); klass = AbstractMetaClass::findClass(classes, u"SubjectBase"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasVirtualDestructor()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->hasVirtualDestructor()); } @@ -145,11 +145,11 @@ protected: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *klass = AbstractMetaClass::findClass(classes, u"Control"); - QVERIFY(klass); + auto klass = AbstractMetaClass::findClass(classes, u"Control"); + QVERIFY(!klass.isNull()); QVERIFY(klass->isPolymorphic()); klass = AbstractMetaClass::findClass(classes, u"Subject"); - QVERIFY(klass); + QVERIFY(!klass.isNull()); QVERIFY(klass->isPolymorphic()); } diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp index e45da9e70..018c0d231 100644 --- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp @@ -54,7 +54,7 @@ void TestEnum::testEnumCppSignature() u"A::ClassEnum"); // enum as parameter of a method - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); QCOMPARE(classA->enums().size(), 1); const auto funcs = classA->queryFunctionsByName(u"method"_s); QVERIFY(!funcs.isEmpty()); @@ -286,8 +286,8 @@ void TestEnum::testEnumValueFromExpression() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); auto enumA = classA->findEnum(u"EnumA"_s); QVERIFY(enumA.has_value()); @@ -364,8 +364,8 @@ void TestEnum::testPrivateEnum() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->enums().size(), 2); auto privateEnum = classA->findEnum(u"PrivateEnum"_s); @@ -472,14 +472,14 @@ namespace Test2 fixture->globalEnum = AbstractMetaType(globalEnums.constFirst().typeEntry()); fixture->globalEnum.decideUsagePattern(); - const AbstractMetaClass *testNamespace = nullptr; - for (auto *c : fixture->builder->classes()) { + AbstractMetaClassCPtr testNamespace; + for (const auto &c : fixture->builder->classes()) { if (c->name() == u"Test2") { testNamespace = c; break; } } - if (!testNamespace) + if (testNamespace.isNull()) return -3; const auto namespaceEnums = testNamespace->enums(); diff --git a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp index 048626d2a..befa3a2b9 100644 --- a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp @@ -23,8 +23,8 @@ void TestExtraInclude::testClassExtraInclude() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QList<Include> includes = classA->typeEntry()->extraIncludes(); QCOMPARE(includes.size(), 1); diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp index eabd8b046..5c33512b7 100644 --- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp @@ -33,8 +33,8 @@ void TestImplicitConversions::testWithPrivateCtors() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classC = AbstractMetaClass::findClass(classes, u"C"); const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.size(), 1); QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(), @@ -62,8 +62,8 @@ void TestImplicitConversions::testWithModifiedVisibility() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.size(), 1); QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(), @@ -97,12 +97,12 @@ void TestImplicitConversions::testWithAddedCtor() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.size(), 2); // Added constructors with custom types should never result in implicit converters. - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); implicitConvs = classB->implicitConversions(); QCOMPARE(implicitConvs.size(), 0); } @@ -123,8 +123,8 @@ void TestImplicitConversions::testWithExternalConversionOperator() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.size(), 1); const auto &externalConvOps = classA->externalConversionOperators(); diff --git a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp index ffab76923..a063b37d0 100644 --- a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp @@ -28,8 +28,8 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->typeEntry()->codeSnips().size(), 1); QString code = classA->typeEntry()->codeSnips().constFirst().code(); QVERIFY(code.contains(u"code template content")); diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp index 168f1a67b..49c5b525f 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp @@ -34,8 +34,8 @@ R"(<typesystem package="Foo"> )"; QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); - AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); DocModificationList docMods = classA->typeEntry()->docModifications(); QCOMPARE(docMods.size(), 2); QCOMPARE(docMods[0].code().trimmed(), u"<brief>Modified Brief</brief>"); @@ -95,8 +95,8 @@ void TestModifyDocumentation::testInjectAddedFunctionDocumentation() )XML"; QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); - AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); const auto f = classA->findFunction(u"foo"); QVERIFY(!f.isNull()); QVERIFY(f->isUserAdded()); diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp index 2b2525a8c..4f98c7240 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp @@ -48,7 +48,7 @@ void TestModifyFunction::testRenameArgument() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.constData(), false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); const auto func = classA->findFunction(u"method"); QVERIFY(!func.isNull()); @@ -76,7 +76,7 @@ void TestModifyFunction::testOwnershipTransfer() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); const auto func = classB->findFunction(u"method"); QVERIFY(!func.isNull()); @@ -126,14 +126,14 @@ void TestModifyFunction::invalidateAfterUse() false, u"0.1"_s)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); auto func = classB->findFunction(u"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()); - const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C"); - QVERIFY(classC); + const auto classC = AbstractMetaClass::findClass(classes, u"C"); + QVERIFY(!classC.isNull()); func = classC->findFunction(u"call"); QCOMPARE(func->modifications().size(), 1); QCOMPARE(func->modifications().at(0).argument_mods().size(), 1); @@ -144,7 +144,7 @@ void TestModifyFunction::invalidateAfterUse() QCOMPARE(func->modifications().at(0).argument_mods().size(), 1); QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse()); - const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"D"); + AbstractMetaClassCPtr classD = AbstractMetaClass::findClass(classes, u"D"); QVERIFY(classD); func = classD->findFunction(u"call"); QCOMPARE(func->modifications().size(), 1); @@ -156,8 +156,8 @@ void TestModifyFunction::invalidateAfterUse() QCOMPARE(func->modifications().at(0).argument_mods().size(), 1); QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse()); - const AbstractMetaClass *classE = AbstractMetaClass::findClass(classes, u"E"); - QVERIFY(classE); + const auto classE = AbstractMetaClass::findClass(classes, u"E"); + QVERIFY(!classE.isNull()); func = classE->findFunction(u"call"); QVERIFY(func); QCOMPARE(func->modifications().size(), 1); @@ -199,7 +199,7 @@ void TestModifyFunction::testWithApiVersion() false, u"0.1"_s)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); auto func = classB->findFunction(u"method"); auto returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0); @@ -238,8 +238,8 @@ struct A { false, u"0.1"_s)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); // Nothing specified, true const auto f1 = classA->findFunction(u"f1"); @@ -436,8 +436,8 @@ void TestModifyFunction::testScopedModifications() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode.constData(), xmlCode.constData(), false)); QVERIFY(!builder.isNull()); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A"); + QVERIFY(!classA.isNull()); auto f = classA->findFunction(QStringLiteral("unspecified")); QVERIFY(!f.isNull()); diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp index a3f955602..62f95b67e 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp @@ -35,7 +35,7 @@ void TestMultipleInheritance::testVirtualClass() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 4); - const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"D"); + const auto classD = AbstractMetaClass::findClass(classes, u"D"); bool functionFound = false; for (const auto &f : classD->functions()) { if (f->name() == u"theBug") { diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp index 248812048..fe7055343 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp @@ -33,8 +33,8 @@ void NamespaceTest::testNamespaceMembers() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - AbstractMetaClass *ns = AbstractMetaClass::findClass(classes, u"Namespace"); - QVERIFY(ns); + const auto ns = AbstractMetaClass::findClass(classes, u"Namespace"); + QVERIFY(!ns.isNull()); auto metaEnum = ns->findEnum(u"Option"_s); QVERIFY(metaEnum.has_value()); const auto func = ns->findFunction(u"foo"); @@ -63,12 +63,12 @@ void NamespaceTest::testNamespaceInnerClassMembers() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *ons = AbstractMetaClass::findClass(classes, u"OuterNamespace"); - QVERIFY(ons); - const AbstractMetaClass *ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace"); - QVERIFY(ins); - const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass"); - QVERIFY(sc); + const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace"); + QVERIFY(!ons.isNull()); + const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace"); + QVERIFY(!ins.isNull()); + const auto sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass"); + QVERIFY(!sc.isNull()); const auto meth = sc->findFunction(u"method"); QVERIFY(!meth.isNull()); } diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp index f6daab0b8..028af5e1d 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp @@ -46,11 +46,11 @@ void TestNestedTypes::testNestedTypesModifications() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *ons = AbstractMetaClass::findClass(classes, u"OuterNamespace"); - QVERIFY(ons); + const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace"); + QVERIFY(!ons.isNull()); - auto *ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace"); - QVERIFY(ins); + const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace"); + QVERIFY(!ins.isNull()); QCOMPARE(ins->functions().size(), 1); QCOMPARE(ins->typeEntry()->codeSnips().size(), 1); CodeSnip snip = ins->typeEntry()->codeSnips().constFirst(); @@ -68,8 +68,9 @@ void TestNestedTypes::testNestedTypesModifications() snip = addedFunc->modifications().constFirst().snips().constFirst(); QCOMPARE(snip.code().trimmed(), u"custom_code2();"); - auto *sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass"); - QVERIFY(ins); + const auto sc = + AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass"); + QVERIFY(!sc.isNull()); QCOMPARE(sc->functions().size(), 2); // default constructor and removed method const auto removedFunc = sc->functions().constLast(); QVERIFY(removedFunc->isModifiedRemoved()); @@ -95,12 +96,12 @@ void TestNestedTypes::testDuplicationOfNestedTypes() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 2); - auto *nspace = AbstractMetaClass::findClass(classes, u"Namespace"); - QVERIFY(nspace); - auto *cls1 = AbstractMetaClass::findClass(classes, u"SomeClass"); - QVERIFY(cls1); - auto *cls2 = AbstractMetaClass::findClass(classes, u"Namespace::SomeClass"); - QVERIFY(cls2); + const auto nspace = AbstractMetaClass::findClass(classes, u"Namespace"); + QVERIFY(!nspace.isNull()); + const auto cls1 = AbstractMetaClass::findClass(classes, u"SomeClass"); + QVERIFY(!cls1.isNull()); + const auto cls2 = AbstractMetaClass::findClass(classes, u"Namespace::SomeClass"); + QVERIFY(!cls2.isNull()); QCOMPARE(cls1, cls2); QCOMPARE(cls1->name(), u"SomeClass"); QCOMPARE(cls1->qualifiedCppName(), u"Namespace::SomeClass"); diff --git a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp index ba2b25829..76ce7a1e1 100644 --- a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp @@ -27,8 +27,8 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); auto typeEntry = TypeDatabase::instance()->findPrimitiveType(u"A"_s); QVERIFY(!typeEntry.isNull()); diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp index ef83d99fb..76eccf27c 100644 --- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp @@ -34,7 +34,7 @@ void TestRefCountTag::testReferenceCountTag() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); const auto func = classB->findFunction(u"keepObject"); QVERIFY(!func.isNull()); const auto refCount = @@ -68,7 +68,7 @@ void TestRefCountTag::testWithApiVersion() false, u"0.1"_s)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); const auto func = classB->findFunction(u"keepObject"); QVERIFY(!func.isNull()); const auto refCount = diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp index 74a0adcea..89a5f78c6 100644 --- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp @@ -25,8 +25,8 @@ void TestReferenceToPointer::testReferenceToPointerArgument() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); const auto func = classB->findFunction(u"dummy"); QVERIFY(!func.isNull()); QCOMPARE(func->arguments().constFirst().type().minimalSignature(), u"A*&"); diff --git a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp index e0acb0e5b..7f8244160 100644 --- a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp @@ -25,8 +25,8 @@ void TestRemoveField::testRemoveField() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->fields().size(), 1); const AbstractMetaField &fieldA = classA->fields().constFirst(); QCOMPARE(fieldA.name(), u"fieldA"); diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp index 59528d517..5d22739c7 100644 --- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp @@ -33,12 +33,12 @@ void TestRemoveImplConv::testRemoveImplConv() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); - const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, u"C"); - QVERIFY(classC); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); + const auto classC = AbstractMetaClass::findClass(classes, u"C"); + QVERIFY(!classC.isNull()); const auto implConv = classC->implicitConversions(); QCOMPARE(implConv.size(), 1); QCOMPARE(implConv.constFirst()->arguments().constFirst().type().typeEntry(), diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp index a6d929c8f..d7b716c6a 100644 --- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp @@ -69,8 +69,8 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->functions().size(), 14); QStringList removedSignatures; removedSignatures.append(u"operator>>(char&)"_s); diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp index a798c4339..b87bfb6a1 100644 --- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp @@ -47,8 +47,8 @@ void TestResolveType::testResolveReturnTypeFromParentScope() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"A::D"); - QVERIFY(classD); + const auto classD = AbstractMetaClass::findClass(classes, u"A::D"); + QVERIFY(!classD.isNull()); const auto meth = classD->findFunction(u"method"); QVERIFY(!meth.isNull()); QVERIFY(meth); @@ -66,7 +66,7 @@ struct DefaultValuesFixture AbstractMetaType stringType; AbstractMetaType classType; AbstractMetaType listType; - const AbstractMetaClass *klass{}; + AbstractMetaClassCPtr klass{}; }; Q_DECLARE_METATYPE(DefaultValuesFixture) @@ -253,8 +253,8 @@ public: QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *testClass = AbstractMetaClass::findClass(classes, u"Test"); - QVERIFY(testClass); + const auto testClass = AbstractMetaClass::findClass(classes, u"Test"); + QVERIFY(!testClass.isNull()); auto *tdb = TypeDatabase::instance(); auto int32TEntry = tdb->findType(u"int32_t"_s); diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp index 0e191668b..9bebf1c10 100644 --- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp @@ -27,8 +27,8 @@ void TestReverseOperators::testReverseSum() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->functions().size(), 4); AbstractMetaFunctionCPtr reverseOp; @@ -69,12 +69,12 @@ void TestReverseOperators::testReverseSumWithAmbiguity() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QCOMPARE(classA->functions().size(), 4); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); QCOMPARE(classB->functions().size(), 4); AbstractMetaFunctionCPtr reverseOp; @@ -114,8 +114,8 @@ void TestReverseOperators::testSpaceshipOperator() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - const AbstractMetaClass *testClass = AbstractMetaClass::findClass(classes, u"Test"); - QVERIFY(testClass); + const auto testClass = AbstractMetaClass::findClass(classes, u"Test"); + QVERIFY(!testClass.isNull()); const auto &functions = testClass->functions(); // 6 operators should be synthesized const auto count = std::count_if(functions.cbegin(), functions.cend(), diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp index 65c95e378..3be0a9a35 100644 --- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp @@ -58,8 +58,8 @@ namespace Internet { QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classB = AbstractMetaClass::findClass(classes, u"Bookmarks"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"Bookmarks"); + QVERIFY(!classB.isNull()); const auto func = classB->findFunction(u"list"); QVERIFY(!func.isNull()); AbstractMetaType funcType = func->type(); @@ -96,8 +96,8 @@ namespace Namespace { QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); QVERIFY(!classB->baseClass()); QVERIFY(classB->baseClassName().isEmpty()); const auto func = classB->findFunction(u"foo"); @@ -213,7 +213,7 @@ struct List { const AbstractMetaClassList templates = builder->templates(); QCOMPARE(templates.size(), 1); - const AbstractMetaClass *list = templates.constFirst(); + AbstractMetaClassCPtr list = templates.constFirst(); // Verify that the parameter of "void append(List l)" gets fixed to "List<T >" const auto append = list->findFunction(QStringLiteral("append")); QVERIFY(!append.isNull()); @@ -256,10 +256,10 @@ struct FooBars : public ListContainer<FooBar> {}; QCOMPARE(classes.size(), 2); QCOMPARE(templates.size(), 1); - const auto *foobars = AbstractMetaClass::findClass(classes, u"FooBars"); + const auto foobars = AbstractMetaClass::findClass(classes, u"FooBars"); QCOMPARE(foobars->functions().size(), 4); - const AbstractMetaClass *lc = templates.constFirst(); + AbstractMetaClassCPtr lc = templates.constFirst(); QCOMPARE(lc->functions().size(), 2); } @@ -290,8 +290,8 @@ template<SomeEnum type> struct Future {}; QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); QVERIFY(!classB->baseClass()); QVERIFY(classB->baseClassName().isEmpty()); // 3 functions: simple constructor, copy constructor and "method()". @@ -329,8 +329,8 @@ template<SomeEnum type> struct Future {}; QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto *classB = AbstractMetaClass::findClass(classes, u"Namespace::B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"Namespace::B"); + QVERIFY(!classB.isNull()); QVERIFY(!classB->baseClass()); QVERIFY(classB->baseClassName().isEmpty()); // 3 functions: simple constructor, copy constructor and "method()". @@ -366,10 +366,10 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass; AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 3); - const auto *base = AbstractMetaClass::findClass(classes, u"BaseTemplateClass"); - QVERIFY(base); - const auto *one = AbstractMetaClass::findClass(classes, u"TypeOneClass"); - QVERIFY(one); + const auto base = AbstractMetaClass::findClass(classes, u"BaseTemplateClass"); + QVERIFY(!base.isNull()); + const auto one = AbstractMetaClass::findClass(classes, u"TypeOneClass"); + QVERIFY(!one.isNull()); QCOMPARE(one->templateBaseClass(), base); QCOMPARE(one->functions().size(), base->functions().size()); QVERIFY(one->isTypeDef()); @@ -415,8 +415,8 @@ typedef Vector<int> IntVector; AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - auto *vector = AbstractMetaClass::findClass(classes, u"IntVector"); - QVERIFY(vector); + const auto vector = AbstractMetaClass::findClass(classes, u"IntVector"); + QVERIFY(!vector.isNull()); auto baseContainer = vector->typeEntry()->baseContainerType(); QVERIFY(!baseContainer.isNull()); QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(), @@ -541,19 +541,17 @@ void TestTemplates::testTemplateTypeDefs() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *optional = AbstractMetaClass::findClass(classes, u"Optional"); - QVERIFY(optional); + const auto optional = AbstractMetaClass::findClass(classes, u"Optional"); + QVERIFY(!optional.isNull()); // Find the typedef'ed class - const AbstractMetaClass *optionalInt = - AbstractMetaClass::findClass(classes, u"IntOptional"); - QVERIFY(optionalInt); + const auto optionalInt = AbstractMetaClass::findClass(classes, u"IntOptional"); + QVERIFY(!optionalInt.isNull()); QCOMPARE(optionalInt->templateBaseClass(), optional); // Find the class typedef'ed in the typesystem XML - const AbstractMetaClass *xmlOptionalInt = - AbstractMetaClass::findClass(classes, u"XmlIntOptional"); - QVERIFY(xmlOptionalInt); + const auto xmlOptionalInt = AbstractMetaClass::findClass(classes, u"XmlIntOptional"); + QVERIFY(!xmlOptionalInt.isNull()); QCOMPARE(xmlOptionalInt->templateBaseClass(), optional); // Check whether the value() method now has an 'int' return @@ -612,8 +610,8 @@ public: QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - auto testClass = AbstractMetaClass::findClass(classes, u"Test"); - QVERIFY(testClass); + const auto testClass = AbstractMetaClass::findClass(classes, u"Test"); + QVERIFY(!testClass.isNull()); auto fields = testClass->fields(); QCOMPARE(fields.size(), 1); @@ -621,8 +619,8 @@ public: QCOMPARE(fieldType.name(), u"Container1"); QCOMPARE(fieldType.instantiations().size(), 1); - auto derived = AbstractMetaClass::findClass(classes, u"Derived"); - QVERIFY(derived); + const auto derived = AbstractMetaClass::findClass(classes, u"Derived"); + QVERIFY(!derived.isNull()); auto base = derived->templateBaseClass(); QCOMPARE(base->name(), u"Container1"); } diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp index 1ebe71ef6..400979c4c 100644 --- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp @@ -32,13 +32,13 @@ void TestTypeRevision::testRevisionAttr() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *rev0 = AbstractMetaClass::findClass(classes, u"Rev_0"); + const auto rev0 = AbstractMetaClass::findClass(classes, u"Rev_0"); QCOMPARE(rev0->typeEntry()->revision(), 0); - const AbstractMetaClass *rev1 = AbstractMetaClass::findClass(classes, u"Rev_1"); + const auto rev1 = AbstractMetaClass::findClass(classes, u"Rev_1"); QCOMPARE(rev1->typeEntry()->revision(), 1); - AbstractMetaClass *rev2 = AbstractMetaClass::findClass(classes, u"Rev_2"); + const auto rev2 = AbstractMetaClass::findClass(classes, u"Rev_2"); QCOMPARE(rev2->typeEntry()->revision(), 2); auto rev3 = rev2->findEnum(u"Rev_3"_s); diff --git a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp index 06fbe9ee3..2e762c1f9 100644 --- a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp @@ -26,13 +26,13 @@ void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument() AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); QVERIFY(classA->typeEntry()->hasDefaultConstructor()); QCOMPARE(classA->typeEntry()->defaultConstructor(), u"A(0, 0)"); - const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, u"B"); - QVERIFY(classB); + const auto classB = AbstractMetaClass::findClass(classes, u"B"); + QVERIFY(!classB.isNull()); QVERIFY(!classB->typeEntry()->hasDefaultConstructor()); } diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp index 255a33953..daf0d2aa5 100644 --- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp @@ -19,8 +19,8 @@ void TestVoidArg::testVoidParsedFunction() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"a"); QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().size(), 0); @@ -38,8 +38,8 @@ void TestVoidArg::testVoidAddedFunction() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"a"); QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().size(), 0); @@ -56,8 +56,8 @@ void TestVoidArg::testVoidPointerParsedFunction() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); - const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, u"A"); - QVERIFY(classA); + const auto classA = AbstractMetaClass::findClass(classes, u"A"); + QVERIFY(!classA.isNull()); const auto addedFunc = classA->findFunction(u"a"); QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().size(), 1); diff --git a/sources/shiboken6/ApiExtractor/usingmember.h b/sources/shiboken6/ApiExtractor/usingmember.h index ed362688d..346eab13c 100644 --- a/sources/shiboken6/ApiExtractor/usingmember.h +++ b/sources/shiboken6/ApiExtractor/usingmember.h @@ -12,7 +12,7 @@ QT_FORWARD_DECLARE_CLASS(QDebug) struct UsingMember // Introducing a base class member via 'using' directive { QString memberName; - const AbstractMetaClass *baseClass; + AbstractMetaClassCPtr baseClass; Access access; }; |