diff options
| author | Friedemann Kleint <Friedemann.Kleint@qt.io> | 2022-12-02 08:53:29 +0100 |
|---|---|---|
| committer | Friedemann Kleint <Friedemann.Kleint@qt.io> | 2022-12-06 08:35:36 +0100 |
| commit | d0ff4bbf69ebaf34a6108b3406bf67451e8778d2 (patch) | |
| tree | ff99e5c6cc9d37c9c80c553ca729e39540c21035 /sources/shiboken6 | |
| parent | 2d7c438cc4c13b22bbe45e937cbdb4215239fd29 (diff) | |
shiboken6: Use smart pointers for AbstractMetaClass instances
Change-Id: I101ca8ceea6ffa63ca8bd03e2e9adf7531cb8f80
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
Diffstat (limited to 'sources/shiboken6')
74 files changed, 1104 insertions, 1068 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; }; diff --git a/sources/shiboken6/generator/generator.cpp b/sources/shiboken6/generator/generator.cpp index b1accb74b..81d69fa09 100644 --- a/sources/shiboken6/generator/generator.cpp +++ b/sources/shiboken6/generator/generator.cpp @@ -66,10 +66,10 @@ bool Generator::setup(const ApiExtractorResult &api) return false; } - for (auto c : api.classes()) { + for (const auto &c : api.classes()) { if (c->enclosingClass() == nullptr && c->isInvisibleNamespace()) { m_d->m_invisibleTopNamespaces.append(c); - c->invisibleNamespaceRecursion([&](const AbstractMetaClass *ic) { + c->invisibleNamespaceRecursion([&](const AbstractMetaClassCPtr &ic) { m_d->m_invisibleTopNamespaces.append(ic); }); } @@ -104,7 +104,7 @@ QString Generator::fileNameForContextHelper(const GeneratorContext &context, { if (!context.forSmartPointer()) { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); QString fileNameBase = flags.testFlag(FileNameFlag::UnqualifiedName) ? metaClass->name() : metaClass->qualifiedCppName(); if (!flags.testFlag(FileNameFlag::KeepCase)) @@ -176,7 +176,7 @@ void Generator::setOutputDirectory(const QString &outDir) bool Generator::generateFileForContext(const GeneratorContext &context) { - const AbstractMetaClass *cls = context.metaClass(); + const auto cls = context.metaClass(); auto typeEntry = cls->typeEntry(); if (!shouldGenerate(typeEntry)) @@ -209,16 +209,17 @@ QString Generator::getFileNameBaseForSmartPointer(const AbstractMetaType &smartP return fileName; } -GeneratorContext Generator::contextForClass(const AbstractMetaClass *c) const +GeneratorContext Generator::contextForClass(const AbstractMetaClassCPtr &c) const { GeneratorContext result; result.m_metaClass = c; return result; } -GeneratorContext Generator::contextForSmartPointer(const AbstractMetaClass *c, - const AbstractMetaType &t, - const AbstractMetaClass *pointeeClass) +GeneratorContext + Generator::contextForSmartPointer(const AbstractMetaClassCPtr &c, + const AbstractMetaType &t, + const AbstractMetaClassCPtr &pointeeClass) { GeneratorContext result; result.m_metaClass = c; @@ -230,7 +231,7 @@ GeneratorContext Generator::contextForSmartPointer(const AbstractMetaClass *c, bool Generator::generate() { - for (auto cls : m_d->api.classes()) { + for (const auto &cls : m_d->api.classes()) { if (!generateFileForContext(contextForClass(cls))) return false; auto te = cls->typeEntry(); @@ -239,7 +240,7 @@ bool Generator::generate() } for (const auto &smp: m_d->api.instantiatedSmartPointers()) { - const AbstractMetaClass *pointeeClass = nullptr; + AbstractMetaClassCPtr pointeeClass; const auto instantiatedType = smp.type.instantiations().constFirst().typeEntry(); if (instantiatedType->isComplex()) // not a C++ primitive pointeeClass = AbstractMetaClass::findClass(m_d->api.classes(), instantiatedType); @@ -302,7 +303,7 @@ QString Generator::getFullTypeName(const AbstractMetaType &type) return typeName + QString::fromLatin1("*").repeated(type.indirections()); } -QString Generator::getFullTypeName(const AbstractMetaClass *metaClass) +QString Generator::getFullTypeName(const AbstractMetaClassCPtr &metaClass) { return u"::"_s + metaClass->qualifiedCppName(); } @@ -455,7 +456,7 @@ static QString constructorCall(const QString &qualifiedCppName, const QStringLis std::optional<DefaultValue> Generator::minimalConstructor(const ApiExtractorResult &api, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, QString *errorString) { if (!metaClass) @@ -521,7 +522,7 @@ std::optional<DefaultValue> } QString Generator::translateType(AbstractMetaType cType, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, Options options) const { QString s; @@ -614,10 +615,10 @@ QString Generator::subDirectoryForPackage(QString packageNameIn) const } template<typename T> -static QString getClassTargetFullName_(const T *t, bool includePackageName) +static QString getClassTargetFullName_(T t, bool includePackageName) { QString name = t->name(); - const AbstractMetaClass *context = t->enclosingClass(); + AbstractMetaClassCPtr context = t->enclosingClass(); while (context) { // If the type was marked as 'visible=false' we should not use it in // the type name @@ -634,12 +635,14 @@ static QString getClassTargetFullName_(const T *t, bool includePackageName) return name; } -QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName) +QString getClassTargetFullName(const AbstractMetaClassCPtr &metaClass, + bool includePackageName) { return getClassTargetFullName_(metaClass, includePackageName); } -QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName) +QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, + bool includePackageName) { return getClassTargetFullName_(&metaEnum, includePackageName); } diff --git a/sources/shiboken6/generator/generator.h b/sources/shiboken6/generator/generator.h index 131ad427d..03c44fc9b 100644 --- a/sources/shiboken6/generator/generator.h +++ b/sources/shiboken6/generator/generator.h @@ -16,8 +16,10 @@ class GeneratorContext; class DefaultValue; class TextStream; -QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName = true); -QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, bool includePackageName = true); +QString getClassTargetFullName(const AbstractMetaClassCPtr &metaClass, + bool includePackageName = true); +QString getClassTargetFullName(const AbstractMetaEnum &metaEnum, + bool includePackageName = true); QString getFilteredCppSignatureString(QString signature); /** @@ -120,10 +122,10 @@ protected: /// Returns all container types found by APIExtractor static ContainerTypeEntryCList containerTypes(); - virtual GeneratorContext contextForClass(const AbstractMetaClass *c) const; - static GeneratorContext contextForSmartPointer(const AbstractMetaClass *c, - const AbstractMetaType &t, - const AbstractMetaClass *pointeeClass = nullptr); + virtual GeneratorContext contextForClass(const AbstractMetaClassCPtr &c) const; + static GeneratorContext + contextForSmartPointer(const AbstractMetaClassCPtr &c, const AbstractMetaType &t, + const AbstractMetaClassCPtr &pointeeClass = {}); /// Generates a file for given AbstractMetaClass or AbstractMetaType (smart pointer case). bool generateFileForContext(const GeneratorContext &context); @@ -142,7 +144,7 @@ protected: * \return the metatype translated to binding source format */ QString translateType(AbstractMetaType metatype, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, Options options = NoOption) const; /** @@ -153,7 +155,7 @@ protected: // Returns the full name of the type. static QString getFullTypeName(TypeEntryCPtr type); static QString getFullTypeName(const AbstractMetaType &type); - static QString getFullTypeName(const AbstractMetaClass *metaClass); + static QString getFullTypeName(const AbstractMetaClassCPtr &metaClass); /** * Returns the full qualified C++ name for an AbstractMetaType, but removing modifiers @@ -175,7 +177,7 @@ protected: QString *errorString = nullptr); static std::optional<DefaultValue> minimalConstructor(const ApiExtractorResult &api, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, QString *errorString = nullptr); /** diff --git a/sources/shiboken6/generator/generatorcontext.h b/sources/shiboken6/generator/generatorcontext.h index 573f98758..2e58d4346 100644 --- a/sources/shiboken6/generator/generatorcontext.h +++ b/sources/shiboken6/generator/generatorcontext.h @@ -31,9 +31,9 @@ public: GeneratorContext() = default; - const AbstractMetaClass *metaClass() const { return m_metaClass; } + AbstractMetaClassCPtr metaClass() const { return m_metaClass; } const AbstractMetaType &preciseType() const { return m_preciseClassType; } - const AbstractMetaClass *pointeeClass() const { return m_pointeeClass; } + AbstractMetaClassCPtr pointeeClass() const { return m_pointeeClass; } bool forSmartPointer() const { return m_type == SmartPointer; } bool useWrapper() const { return m_type == WrappedClass; } @@ -44,8 +44,8 @@ public: QString effectiveClassName() const; private: - const AbstractMetaClass *m_metaClass = nullptr; - const AbstractMetaClass *m_pointeeClass = nullptr; + AbstractMetaClassCPtr m_metaClass; + AbstractMetaClassCPtr m_pointeeClass; AbstractMetaType m_preciseClassType; QString m_wrappername; Type m_type = Class; diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp index 8f80930b8..6dba04b25 100644 --- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp +++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp @@ -72,7 +72,7 @@ static bool operator<(const GeneratorDocumentation::Property &lhs, return lhs.name < rhs.name; } -static QString propertyRefTarget(const AbstractMetaClass *cppClass, const QString &name) +static QString propertyRefTarget(const AbstractMetaClassCPtr &cppClass, const QString &name) { QString result = cppClass->fullName() + u'.' + name; result.replace(u"::"_s, u"."_s); @@ -139,12 +139,13 @@ static inline QVersionNumber versionOf(const TypeEntryCPtr &te) // for functions where we list the parameters instead. struct docRef { - explicit docRef(const char *kind, const QString &name, const AbstractMetaClass *cppClass) : + explicit docRef(const char *kind, const QString &name, + const AbstractMetaClassCPtr &cppClass) : m_kind(kind), m_name(name), m_cppClass(cppClass) {} const char *m_kind; const QString &m_name; - const AbstractMetaClass *m_cppClass; + const AbstractMetaClassCPtr m_cppClass; }; static TextStream &operator<<(TextStream &s, const docRef &dr) @@ -177,18 +178,18 @@ static TextStream &operator<<(TextStream &s, const shortDocRef &sdr) struct functionRef : public docRef { - explicit functionRef(const QString &name, const AbstractMetaClass *cppClass) : + explicit functionRef(const QString &name, const AbstractMetaClassCPtr &cppClass) : docRef("meth", name, cppClass) {} }; struct functionTocEntry // Format a TOC entry for a function { explicit functionTocEntry(const AbstractMetaFunctionCPtr& func, - const AbstractMetaClass *cppClass) : + const AbstractMetaClassCPtr &cppClass) : m_func(func), m_cppClass(cppClass) {} AbstractMetaFunctionCPtr m_func; - const AbstractMetaClass *m_cppClass; + const AbstractMetaClassCPtr m_cppClass; }; static TextStream &operator<<(TextStream &s, const functionTocEntry &ft) @@ -231,20 +232,20 @@ QString QtDocGenerator::fileNameForContext(const GeneratorContext &context) cons } void QtDocGenerator::writeFormattedBriefText(TextStream &s, const Documentation &doc, - const AbstractMetaClass *metaclass) const + const AbstractMetaClassCPtr &metaclass) const { writeFormattedText(s, doc.brief(), doc.format(), metaclass); } void QtDocGenerator::writeFormattedDetailedText(TextStream &s, const Documentation &doc, - const AbstractMetaClass *metaclass) const + const AbstractMetaClassCPtr &metaclass) const { writeFormattedText(s, doc.detailed(), doc.format(), metaclass); } void QtDocGenerator::writeFormattedText(TextStream &s, const QString &doc, Documentation::Format format, - const AbstractMetaClass *metaClass) const + const AbstractMetaClassCPtr &metaClass) const { QString metaClassName; @@ -276,11 +277,11 @@ void QtDocGenerator::writeFormattedText(TextStream &s, const QString &doc, s << '\n'; } -static void writeInheritedByList(TextStream &s, const AbstractMetaClass *metaClass, +static void writeInheritedByList(TextStream &s, const AbstractMetaClassCPtr &metaClass, const AbstractMetaClassCList& allClasses) { AbstractMetaClassCList res; - for (auto c : allClasses) { + for (const auto &c : allClasses) { if (c != metaClass && inheritsFrom(c, metaClass)) res << c; } @@ -290,20 +291,20 @@ static void writeInheritedByList(TextStream &s, const AbstractMetaClass *metaCla s << "**Inherited by:** "; QStringList classes; - for (auto c : std::as_const(res)) + for (const auto &c : std::as_const(res)) classes << u":ref:`"_s + c->name() + u'`'; s << classes.join(u", "_s) << "\n\n"; } void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classContext) { - const AbstractMetaClass *metaClass = classContext.metaClass(); + AbstractMetaClassCPtr metaClass = classContext.metaClass(); qCDebug(lcShibokenDoc).noquote().nospace() << "Generating Documentation for " << metaClass->fullName(); m_packages[metaClass->package()] << fileNameForContext(classContext); m_docParser->setPackageName(metaClass->package()); - m_docParser->fillDocumentation(const_cast<AbstractMetaClass*>(metaClass)); + m_docParser->fillDocumentation(qSharedPointerConstCast<AbstractMetaClass>(metaClass)); QString className = metaClass->name(); s << ".. _" << className << ":" << "\n\n"; @@ -371,7 +372,7 @@ void QtDocGenerator::generateClass(TextStream &s, const GeneratorContext &classC } void QtDocGenerator::writeFunctionToc(TextStream &s, const QString &title, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCList &functions) { if (!functions.isEmpty()) { @@ -387,7 +388,7 @@ void QtDocGenerator::writeFunctionToc(TextStream &s, const QString &title, void QtDocGenerator::writePropertyToc(TextStream &s, const GeneratorDocumentation &doc, - const AbstractMetaClass *cppClass) + const AbstractMetaClassCPtr &cppClass) { if (doc.properties.isEmpty()) return; @@ -408,7 +409,7 @@ void QtDocGenerator::writePropertyToc(TextStream &s, void QtDocGenerator::writeProperties(TextStream &s, const GeneratorDocumentation &doc, - const AbstractMetaClass *cppClass) const + const AbstractMetaClassCPtr &cppClass) const { s << "\n.. note:: Properties can be used directly when " << "``from __feature__ import true_property`` is used or via accessor " @@ -433,7 +434,7 @@ void QtDocGenerator::writeProperties(TextStream &s, } } -void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaClass *cppClass) const +void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaClassCPtr &cppClass) const { static const QString section_title = u".. attribute:: "_s; @@ -447,7 +448,7 @@ void QtDocGenerator::writeEnums(TextStream &s, const AbstractMetaClass *cppClass } -void QtDocGenerator::writeFields(TextStream &s, const AbstractMetaClass *cppClass) const +void QtDocGenerator::writeFields(TextStream &s, const AbstractMetaClassCPtr &cppClass) const { static const QString section_title = u".. attribute:: "_s; @@ -457,7 +458,7 @@ void QtDocGenerator::writeFields(TextStream &s, const AbstractMetaClass *cppClas } } -void QtDocGenerator::writeConstructors(TextStream &s, const AbstractMetaClass *cppClass, +void QtDocGenerator::writeConstructors(TextStream &s, const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCList &constructors) const { static const QString sectionTitle = u".. class:: "_s; @@ -614,7 +615,7 @@ void QtDocGenerator::writeDocSnips(TextStream &s, bool QtDocGenerator::writeInjectDocumentation(TextStream &s, TypeSystem::DocModificationMode mode, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func) { Indentation indentation(s); @@ -652,7 +653,7 @@ bool QtDocGenerator::writeInjectDocumentation(TextStream &s, return didSomething; } -QString QtDocGenerator::functionSignature(const AbstractMetaClass *cppClass, +QString QtDocGenerator::functionSignature(const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func) { QString funcName = cppClass->fullName(); @@ -663,7 +664,7 @@ QString QtDocGenerator::functionSignature(const AbstractMetaClass *cppClass, } QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, bool createRef) const { static const QStringList nativeTypes = @@ -737,14 +738,16 @@ QString QtDocGenerator::getFuncName(const AbstractMetaFunctionCPtr &cppFunc) return result; } -void QtDocGenerator::writeParameterType(TextStream &s, const AbstractMetaClass *cppClass, +void QtDocGenerator::writeParameterType(TextStream &s, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaArgument &arg) const { s << ":param " << arg.name() << ": " << translateToPythonType(arg.type(), cppClass) << '\n'; } -void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass, +void QtDocGenerator::writeFunctionParametersType(TextStream &s, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func) const { s << '\n'; @@ -774,7 +777,7 @@ void QtDocGenerator::writeFunctionParametersType(TextStream &s, const AbstractMe s << '\n'; } -void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaClass *cppClass, +void QtDocGenerator::writeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func, bool indexed) { s << functionSignature(cppClass, func); @@ -877,11 +880,11 @@ bool QtDocGenerator::writeInheritanceFile() throw Exception(msgCannotOpenForWriting(m_inheritanceFile)); QJsonObject dict; - for (auto *c : api().classes()) { + for (const auto &c : api().classes()) { const auto &bases = c->baseClasses(); if (!bases.isEmpty()) { QJsonArray list; - for (auto *base : bases) + for (const auto &base : bases) list.append(QJsonValue(base->fullName())); dict[c->fullName()] = list; } @@ -1183,7 +1186,7 @@ bool QtDocGenerator::convertToRst(const QString &sourceFileName, } GeneratorDocumentation - QtDocGenerator::generatorDocumentation(const AbstractMetaClass *cppClass) const + QtDocGenerator::generatorDocumentation(const AbstractMetaClassCPtr &cppClass) const { GeneratorDocumentation result; const auto allFunctions = cppClass->functions(); @@ -1237,10 +1240,10 @@ GeneratorDocumentation QString QtDocGenerator::expandFunction(const QString &function) const { const int firstDot = function.indexOf(u'.'); - const AbstractMetaClass *metaClass = nullptr; + AbstractMetaClassCPtr metaClass; if (firstDot != -1) { const auto className = QStringView{function}.left(firstDot); - for (auto cls : api().classes()) { + for (const auto &cls : api().classes()) { if (cls->name() == className) { metaClass = cls; break; @@ -1248,10 +1251,10 @@ QString QtDocGenerator::expandFunction(const QString &function) const } } - return metaClass - ? metaClass->typeEntry()->qualifiedTargetLangName() - + function.right(function.size() - firstDot) - : function; + return metaClass.isNull() + ? function + : metaClass->typeEntry()->qualifiedTargetLangName() + + function.right(function.size() - firstDot); } QString QtDocGenerator::expandClass(const QString &context, @@ -1275,15 +1278,15 @@ QString QtDocGenerator::resolveContextForMethod(const QString &context, { const auto currentClass = QStringView{context}.split(u'.').constLast(); - const AbstractMetaClass *metaClass = nullptr; - for (auto cls : api().classes()) { + AbstractMetaClassCPtr metaClass; + for (const auto &cls : api().classes()) { if (cls->name() == currentClass) { metaClass = cls; break; } } - if (metaClass) { + if (!metaClass.isNull()) { AbstractMetaFunctionCList funcList; const auto &methods = metaClass->queryFunctionsByName(methodName); for (const auto &func : methods) { @@ -1291,14 +1294,14 @@ QString QtDocGenerator::resolveContextForMethod(const QString &context, funcList.append(func); } - const AbstractMetaClass *implementingClass = nullptr; + AbstractMetaClassCPtr implementingClass; for (const auto &func : std::as_const(funcList)) { implementingClass = func->implementingClass(); if (implementingClass->name() == currentClass) break; } - if (implementingClass) + if (!implementingClass.isNull()) return implementingClass->typeEntry()->qualifiedTargetLangName(); } diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h index af4b60d2e..3ad78b590 100644 --- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.h +++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.h @@ -56,41 +56,41 @@ protected: bool finishGeneration() override; private: - void writeEnums(TextStream &s, const AbstractMetaClass *cppClass) const; + void writeEnums(TextStream &s, const AbstractMetaClassCPtr &cppClass) const; - void writeFields(TextStream &s, const AbstractMetaClass *cppClass) const; - static QString functionSignature(const AbstractMetaClass *cppClass, + void writeFields(TextStream &s, const AbstractMetaClassCPtr &cppClass) const; + static QString functionSignature(const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func); - void writeFunction(TextStream &s, const AbstractMetaClass *cppClass, + void writeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func, bool indexed = true); - void writeFunctionParametersType(TextStream &s, const AbstractMetaClass *cppClass, + void writeFunctionParametersType(TextStream &s, const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func) const; static void writeFunctionToc(TextStream &s, const QString &title, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCList &functions); void writePropertyToc(TextStream &s, const GeneratorDocumentation &doc, - const AbstractMetaClass *cppClass); + const AbstractMetaClassCPtr &cppClass); void writeProperties(TextStream &s, const GeneratorDocumentation &doc, - const AbstractMetaClass *cppClass) const; - void writeParameterType(TextStream &s, const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass) const; + void writeParameterType(TextStream &s, const AbstractMetaClassCPtr &cppClass, const AbstractMetaArgument &arg) const; void writeConstructors(TextStream &s, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCList &constructors) const; void writeFormattedText(TextStream &s, const QString &doc, Documentation::Format format, - const AbstractMetaClass *metaClass = nullptr) const; + const AbstractMetaClassCPtr &metaClass = {}) const; void writeFormattedBriefText(TextStream &s, const Documentation &doc, - const AbstractMetaClass *metaclass = nullptr) const; + const AbstractMetaClassCPtr &metaclass = {}) const; void writeFormattedDetailedText(TextStream &s, const Documentation &doc, - const AbstractMetaClass *metaclass = nullptr) const; + const AbstractMetaClassCPtr &metaclass = {}) const; bool writeInjectDocumentation(TextStream &s, TypeSystem::DocModificationMode mode, - const AbstractMetaClass *cppClass, + const AbstractMetaClassCPtr &cppClass, const AbstractMetaFunctionCPtr &func); static void writeDocSnips(TextStream &s, const CodeSnipList &codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language); @@ -99,7 +99,8 @@ private: void writeAdditionalDocumentation() const; bool writeInheritanceFile(); - QString translateToPythonType(const AbstractMetaType &type, const AbstractMetaClass *cppClass, + QString translateToPythonType(const AbstractMetaType &type, + const AbstractMetaClassCPtr &cppClass, bool createRef = true) const; bool convertToRst(const QString &sourceFileName, @@ -107,7 +108,7 @@ private: const QString &context = QString(), QString *errorMessage = nullptr) const; - GeneratorDocumentation generatorDocumentation(const AbstractMetaClass *cppClass) const; + GeneratorDocumentation generatorDocumentation(const AbstractMetaClassCPtr &cppClass) const; QString m_extraSectionDir; QStringList m_functionList; diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp index 4795a596d..bf082de8c 100644 --- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp +++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp @@ -238,7 +238,7 @@ static bool skipOperatorFunc(const AbstractMetaFunctionCPtr &func) } QList<AbstractMetaFunctionCList> - CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass, + CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClassCPtr &metaClass, OperatorQueryOptions query) { // ( func_name, num_args ) => func_list @@ -282,7 +282,7 @@ QList<AbstractMetaFunctionCList> } CppGenerator::BoolCastFunctionOptional - CppGenerator::boolCast(const AbstractMetaClass *metaClass) const + CppGenerator::boolCast(const AbstractMetaClassCPtr &metaClass) const { const auto te = metaClass->typeEntry(); if (te->isSmartPointer()) { @@ -501,7 +501,7 @@ static void writePyGetSetDefEntry(TextStream &s, const QString &name, static bool generateRichComparison(const GeneratorContext &c) { - auto *metaClass = c.metaClass(); + const auto metaClass = c.metaClass(); if (c.forSmartPointer()) { auto te = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry()); return te->smartPointerType() == TypeSystem::SmartPointerType::Shared; @@ -514,7 +514,7 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class const IncludeGroupList &includes, const AbstractMetaClassCList &innerClasses) const { - const AbstractMetaClass *metaClass = classContext.metaClass(); + const auto metaClass = classContext.metaClass(); // write license comment s << licenseComment() << '\n'; @@ -571,7 +571,7 @@ void CppGenerator::generateIncludes(TextStream &s, const GeneratorContext &class if (!innerClasses.isEmpty()) { s << "\n// inner classes\n"; - for (const AbstractMetaClass *innerClass : innerClasses) { + for (const auto &innerClass : innerClasses) { GeneratorContext innerClassContext = contextForClass(innerClass); s << "#include \"" << HeaderGenerator::headerFileNameForContext(innerClassContext) << "\"\n"; @@ -610,13 +610,13 @@ static void writePyMethodDefs(TextStream &s, const QString &className, << "};\n\n"; } -static bool hasHashFunction(const AbstractMetaClass *c) +static bool hasHashFunction(const AbstractMetaClassCPtr &c) { return !c->typeEntry()->hashFunction().isEmpty() || c->hasHashFunction(); } -static bool needsTypeDiscoveryFunction(const AbstractMetaClass *c) +static bool needsTypeDiscoveryFunction(const AbstractMetaClassCPtr &c) { return c->baseClass() != nullptr && (c->isPolymorphic() || !c->typeEntry()->polymorphicIdValue().isEmpty()); @@ -646,7 +646,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon } s.setLanguage(TextStream::Language::Cpp); - const AbstractMetaClass *metaClass = classContext.metaClass(); + AbstractMetaClassCPtr metaClass = classContext.metaClass(); const auto typeEntry = metaClass->typeEntry(); auto innerClasses = metaClass->innerClasses(); @@ -671,7 +671,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon // Use class base namespace { - const AbstractMetaClass *context = metaClass->enclosingClass(); + AbstractMetaClassCPtr context = metaClass->enclosingClass(); while (context) { if (context->isNamespace() && !context->enclosingClass() && qSharedPointerCast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) { @@ -958,7 +958,7 @@ static bool hasParameterPredicate(const AbstractMetaFunctionCPtr &f) void CppGenerator::generateSmartPointerClass(TextStream &s, const GeneratorContext &classContext) { s.setLanguage(TextStream::Language::Cpp); - const AbstractMetaClass *metaClass = classContext.metaClass(); + AbstractMetaClassCPtr metaClass = classContext.metaClass(); const auto typeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry()); const bool hasPointeeClass = classContext.pointeeClass() != nullptr; const auto smartPointerType = typeEntry->smartPointerType(); @@ -1845,7 +1845,7 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta } } -void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClass *metaClass, +void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const { s << "// Type conversion functions.\n\n"; @@ -1999,7 +1999,7 @@ return result;)"; QString toCppConv; QString toCppPreConv; if (conv->isConversionOperator()) { - const AbstractMetaClass *sourceClass = conv->ownerClass(); + const auto sourceClass = conv->ownerClass(); typeCheck = u"PyObject_TypeCheck(pyIn, "_s + cpythonTypeNameExt(sourceClass->typeEntry()) + u')'; toCppConv = u'*' + cpythonWrapperCPtr(sourceClass->typeEntry(), @@ -2072,7 +2072,7 @@ void CppGenerator::writeCustomConverterFunctions(TextStream &s, s << '\n'; } -void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass *metaClass, +void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const { const auto typeEntry = metaClass->typeEntry(); @@ -2240,7 +2240,7 @@ void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s, // TODO: Missing conversion to smart pointer pointer type: s << "// Register smartpointer conversion for all derived classes\n"; - for (auto *base : baseClasses) { + for (const auto &base : baseClasses) { auto baseTe = base->typeEntry(); if (smartPointerTypeEntry->matchesInstantiation(baseTe)) { if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) { @@ -2271,7 +2271,7 @@ void CppGenerator::writeMethodWrapperPreamble(TextStream &s,const OverloadData & ErrorReturn errorReturn) const { const auto rfunc = overloadData.referenceFunction(); - const AbstractMetaClass *ownerClass = rfunc->targetLangOwner(); + const auto ownerClass = rfunc->targetLangOwner(); Q_ASSERT(ownerClass == context.metaClass()); int minArgs = overloadData.minArgs(); int maxArgs = overloadData.maxArgs(); @@ -2341,7 +2341,7 @@ void CppGenerator::writeConstructorWrapper(TextStream &s, const OverloadData &ov const ErrorReturn errorReturn = ErrorReturn::MinusOne; const auto rfunc = overloadData.referenceFunction(); - const AbstractMetaClass *metaClass = rfunc->ownerClass(); + const auto metaClass = rfunc->ownerClass(); s << "static int\n"; s << cpythonFunctionName(rfunc) @@ -2602,8 +2602,8 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData & // Disable argument count checks for QObject constructors to allow for // passing properties as KW args. - auto *owner = rfunc->ownerClass(); - bool isQObjectConstructor = owner != nullptr && isQObject(owner) + const auto owner = rfunc->ownerClass(); + bool isQObjectConstructor = !owner.isNull() && isQObject(owner) && rfunc->functionType() == AbstractMetaFunction::ConstructorFunction; if (usesNamedArguments && !isQObjectConstructor) { @@ -2701,7 +2701,7 @@ void CppGenerator::writeCppSelfDefinition(TextStream &s, return; } - const AbstractMetaClass *metaClass = context.metaClass(); + AbstractMetaClassCPtr metaClass = context.metaClass(); const auto cppWrapper = context.metaClass()->cppWrapper(); // In the Python method, use the wrapper to access the protected // functions. @@ -2918,7 +2918,7 @@ qsizetype CppGenerator::writeArgumentConversion(TextStream &s, const QString &argName, const QString &pyArgName, ErrorReturn errorReturn, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, const QString &defaultValue, bool castArgumentAsUnused) const { @@ -2994,7 +2994,7 @@ qsizetype CppGenerator::writePythonToCppTypeConversion(TextStream &s, const AbstractMetaType &type, const QString &pyIn, const QString &cppOut, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, const QString &defaultValue) const { TypeEntryCPtr typeEntry = type.typeEntry(); @@ -3167,7 +3167,7 @@ void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadD s << "// " << i << ": "; if (func->isStatic()) s << "static "; - if (const auto *decl = func->declaringClass()) + if (const auto decl = func->declaringClass(); !decl.isNull()) s << decl->name() << "::"; s << func->signatureComment() << '\n'; } @@ -3285,7 +3285,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s, auto func = od->referenceFunction(); if (func->isConstructor() && func->arguments().size() == 1) { - const AbstractMetaClass *ownerClass = func->ownerClass(); + AbstractMetaClassCPtr ownerClass = func->ownerClass(); ComplexTypeEntryCPtr baseContainerType = ownerClass->typeEntry()->baseContainerType(); if (baseContainerType && baseContainerType == func->arguments().constFirst().type().typeEntry() && ownerClass->isCopyable()) { @@ -3374,7 +3374,7 @@ static void writeDeprecationWarning(TextStream &s, CppGenerator::ErrorReturn errorReturn) { s << "Shiboken::Warnings::warnDeprecated(\""; - if (auto *cls = context.metaClass()) + if (const auto cls = context.metaClass(); !cls.isNull()) s << cls->name() << "\", "; // Check error in case "warning-as-error" is set. s << '"' << func->signature().replace(u"::"_s, u"."_s) << "\");\n" @@ -3774,8 +3774,8 @@ static bool forceQObjectNamedArguments(const AbstractMetaFunctionCPtr &func) { if (func->functionType() != AbstractMetaFunction::ConstructorFunction) return false; - auto *owner = func->ownerClass(); - Q_ASSERT(owner); + const auto owner = func->ownerClass(); + Q_ASSERT(!owner.isNull()); if (!isQObject(owner)) return false; const QString &name = owner->name(); @@ -3863,7 +3863,7 @@ QString CppGenerator::argumentNameFromIndex(const ApiExtractorResult &api, return pythonArgsAt(argIndex - 1); } -const AbstractMetaClass * +AbstractMetaClassCPtr CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api, const AbstractMetaFunctionCPtr &func, int argIndex) { @@ -3888,8 +3888,8 @@ CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api, auto te = type.typeEntry(); if (type.isVoid() || !te->isComplex()) throw Exception(msgInvalidArgumentModification(func, argIndex)); - auto *result = AbstractMetaClass::findClass(api.classes(), te); - if (!result) + const auto result = AbstractMetaClass::findClass(api.classes(), te); + if (result.isNull()) throw Exception(msgClassNotFound(te)); return result; } @@ -4297,8 +4297,8 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr s << "Shiboken::Object::"; if (ownership == TypeSystem::TargetLangOwnership) { s << "getOwnership(" << pyArgName << ");"; - } else if (auto *ac = argumentClassFromIndex(api(), func, argIndex); - ac->hasVirtualDestructor()) { + } else if (auto ac = argumentClassFromIndex(api(), func, argIndex); + !ac.isNull() && ac->hasVirtualDestructor()) { s << "releaseOwnership(" << pyArgName << ");"; } else { s << "invalidate(" << pyArgName << ");"; @@ -4343,12 +4343,12 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr s << propagateException; } -QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass *metaClass) +QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClassCPtr &metaClass) { QStringList result; const auto &baseClases = metaClass->typeSystemBaseClasses(); if (!baseClases.isEmpty()) { - for (const AbstractMetaClass *baseClass : baseClases) { + for (const auto &baseClass : baseClases) { QString offset; QTextStream(&offset) << "reinterpret_cast<uintptr_t>(static_cast<const " << baseClass->qualifiedCppName() << " *>(class_ptr)) - base"; @@ -4361,13 +4361,14 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass result.append(offset); } - for (const AbstractMetaClass *baseClass : baseClases) + for (const auto &baseClass : baseClases) result.append(getAncestorMultipleInheritance(baseClass)); } return result; } -void CppGenerator::writeMultipleInheritanceInitializerFunction(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeMultipleInheritanceInitializerFunction(TextStream &s, + const AbstractMetaClassCPtr &metaClass) { QString className = metaClass->qualifiedCppName(); const QStringList ancestors = getAncestorMultipleInheritance(metaClass); @@ -4391,7 +4392,7 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(TextStream &s, co << "}\nreturn mi_offsets;\n" << outdent << "}\n"; } -void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass) { QString className = metaClass->qualifiedCppName(); s << "static void * " << cpythonSpecialCastFunctionName(metaClass) @@ -4399,7 +4400,7 @@ void CppGenerator::writeSpecialCastFunction(TextStream &s, const AbstractMetaCla << "auto me = reinterpret_cast< ::" << className << " *>(obj);\n"; bool firstClass = true; const auto &allAncestors = metaClass->allTypeSystemAncestors(); - for (const AbstractMetaClass *baseClass : allAncestors) { + for (const auto &baseClass : allAncestors) { if (!firstClass) s << "else "; s << "if (desiredType == " << cpythonTypeNameExt(baseClass->typeEntry()) @@ -4574,7 +4575,7 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const s << "// Register SmartPointer converter for type '" << cppSignature << "'." << '\n' << "///////////////////////////////////////////////////////////////////////////////////////\n\n"; - for (auto *base : classes) { + for (const auto &base : classes) { auto baseTe = base->typeEntry(); if (auto opt = findSmartPointerInstantiation(smartPointerTypeEntry, baseTe)) { const auto smartTargetType = opt.value(); @@ -4597,7 +4598,7 @@ void CppGenerator::writeExtendedConverterInitialization(TextStream &s, { s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << ".\n"; - for (const AbstractMetaClass *sourceClass : conversions) { + for (const auto &sourceClass : conversions) { const QString converterVar = cppApiVariableName(externalType->targetLangPackage()) + u'[' + getTypeIndexVariableName(externalType) + u']'; QString sourceTypeName = fixedCppTypeName(sourceClass->typeEntry()); @@ -4608,12 +4609,12 @@ void CppGenerator::writeExtendedConverterInitialization(TextStream &s, } } -QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass) +QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass->typeEntry()) + u"_mi_init"_s; } -bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass) +bool CppGenerator::supportsMappingProtocol(const AbstractMetaClassCPtr &metaClass) { for (const auto &m : mappingProtocols()) { if (metaClass->hasFunction(m.name)) @@ -4623,7 +4624,7 @@ bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass) return false; } -bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass) const +bool CppGenerator::supportsNumberProtocol(const AbstractMetaClassCPtr &metaClass) const { return metaClass->hasArithmeticOperatorOverload() || metaClass->hasIncDecrementOperatorOverload() @@ -4632,7 +4633,7 @@ bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass) co || hasBoolCast(metaClass); } -bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass) +bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClassCPtr &metaClass) { for (const auto &seq : sequenceProtocols()) { if (metaClass->hasFunction(seq.name)) @@ -4643,7 +4644,7 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass) return baseType && baseType->isContainer(); } -bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass) const +bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClassCPtr &metaClass) const { for (const AbstractMetaField &f : metaClass->fields()) { if (!f.isStatic()) @@ -4683,7 +4684,7 @@ TextStream &operator<<(TextStream &str, const pyTypeSlotEntry &e) } void CppGenerator::writeClassDefinition(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) { QString tp_init; @@ -4778,8 +4779,8 @@ void CppGenerator::writeClassDefinition(TextStream &s, } // class or some ancestor has multiple inheritance - const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass); - if (miClass) { + const auto miClass = getMultipleInheritingClass(metaClass); + if (!miClass.isNull()) { if (metaClass == miClass) writeMultipleInheritanceInitializerFunction(s, metaClass); writeSpecialCastFunction(s, metaClass); @@ -4843,7 +4844,7 @@ void CppGenerator::writeClassDefinition(TextStream &s, } void CppGenerator::writeMappingMethods(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &context) const { for (const auto & m : mappingProtocols()) { @@ -4865,7 +4866,7 @@ void CppGenerator::writeMappingMethods(TextStream &s, } void CppGenerator::writeSequenceMethods(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &context) const { bool injectedCode = false; @@ -4908,7 +4909,7 @@ static const QHash<QString, QString> &sqFuncs() } void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { bool hasFunctions = false; QMap<QString, QString> funcs; @@ -4940,7 +4941,7 @@ void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s, } void CppGenerator::writeTypeAsMappingDefinition(TextStream &s, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { // Sequence protocol structure members names static const QHash<QString, QString> mpFuncs{ @@ -4999,7 +5000,7 @@ static const QHash<QString, QString> &nbFuncs() return result; } -void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClass *metaClass) const +void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) const { QMap<QString, QString> nb; @@ -5047,7 +5048,7 @@ void CppGenerator::writeTypeAsNumberDefinition(TextStream &s, const AbstractMeta } } -void CppGenerator::writeTpTraverseFunction(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeTpTraverseFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass) { QString baseName = cpythonBaseName(metaClass); s << "static int " << baseName @@ -5056,7 +5057,7 @@ void CppGenerator::writeTpTraverseFunction(TextStream &s, const AbstractMetaClas << outdent << "}\n"; } -void CppGenerator::writeTpClearFunction(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeTpClearFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass) { QString baseName = cpythonBaseName(metaClass); s << "static int " << baseName << "_clear(PyObject *self)\n{\n" << indent @@ -5066,7 +5067,7 @@ void CppGenerator::writeTpClearFunction(TextStream &s, const AbstractMetaClass * void CppGenerator::writeCopyFunction(TextStream &s, const GeneratorContext &context) const { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); const QString className = chopType(cpythonTypeName(metaClass)); s << "static PyObject *" << className << "___copy__(PyObject *self)\n" << "{\n" << indent; @@ -5286,7 +5287,7 @@ static const char richCompareComment[] = void CppGenerator::writeRichCompareFunction(TextStream &s, const GeneratorContext &context) const { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); QString baseName = cpythonBaseName(metaClass); writeRichCompareFunctionHeader(s, baseName, context); @@ -5416,8 +5417,8 @@ static ComparisonOperatorList smartPointeeComparisons(const GeneratorContext &co AbstractMetaFunction::OperatorGreaterEqual}; } - auto *pointeeClass = context.pointeeClass(); - if (!pointeeClass) + const auto pointeeClass = context.pointeeClass(); + if (pointeeClass.isNull()) return {}; ComparisonOperatorList result; @@ -5437,7 +5438,7 @@ void CppGenerator::writeSmartPointerRichCompareFunction(TextStream &s, static const char selfPointeeVar[] = "cppSelfPointee"; static const char cppArg0PointeeVar[] = "cppArg0Pointee"; - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); QString baseName = cpythonBaseName(metaClass); writeRichCompareFunctionHeader(s, baseName, context); @@ -5528,9 +5529,9 @@ QByteArrayList CppGenerator::methodDefinitionParameters(const OverloadData &over } // METH_STATIC causes a crash when used for global functions (also from // invisible namespaces). - auto *ownerClass = overloadData.referenceFunction()->ownerClass(); - if (ownerClass - && !invisibleTopNamespaces().contains(const_cast<AbstractMetaClass *>(ownerClass))) { + const auto ownerClass = overloadData.referenceFunction()->ownerClass(); + if (!ownerClass.isNull() + && !invisibleTopNamespaces().contains(qSharedPointerConstCast<AbstractMetaClass>(ownerClass))) { if (overloadData.hasStaticFunction()) result.append(QByteArrayLiteral("METH_STATIC")); if (overloadData.hasClassMethod()) @@ -5676,12 +5677,12 @@ static QString mangleName(QString name) void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum &cppEnum, ErrorReturn errorReturn) const { - const AbstractMetaClass *enclosingClass = cppEnum.targetLangEnclosingClass(); - bool hasUpperEnclosingClass = enclosingClass - && enclosingClass->targetLangEnclosingClass() != nullptr; + const auto enclosingClass = cppEnum.targetLangEnclosingClass(); + const bool hasUpperEnclosingClass = !enclosingClass.isNull() + && !enclosingClass->targetLangEnclosingClass().isNull(); EnumTypeEntryCPtr enumTypeEntry = cppEnum.typeEntry(); QString enclosingObjectVariable; - if (enclosingClass) + if (!enclosingClass.isNull()) enclosingObjectVariable = cpythonTypeName(enclosingClass); else if (hasUpperEnclosingClass) enclosingObjectVariable = u"enclosingClass"_s; @@ -5791,7 +5792,7 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum s << ".\n\n"; } -void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeSignalInitialization(TextStream &s, const AbstractMetaClassCPtr &metaClass) { // Try to check something and print some warnings const auto &signalFuncs = metaClass->cppSignalFunctions(); @@ -5942,7 +5943,7 @@ void CppGenerator::writeFlagsUnaryOperator(TextStream &s, const AbstractMetaEnum s << ";\n" << outdent << "}\n\n"; } -QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClass *metaClass) +QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClassCPtr &metaClass) { QString initFunctionName; // Disambiguate namespaces per module to allow for extending them. @@ -5953,7 +5954,8 @@ QString CppGenerator::getSimpleClassInitFunctionName(const AbstractMetaClass *me return initFunctionName; } -QString CppGenerator::getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClass *metaClass) +QString + CppGenerator::getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClassCPtr &metaClass) { return u"init_"_s + getSimpleClassInitFunctionName(metaClass) + u"StaticFields"_s; @@ -5984,7 +5986,7 @@ void CppGenerator::writeSignatureStrings(TextStream &s, } // Return the class name for which to invoke the destructor -QString CppGenerator::destructorClassName(const AbstractMetaClass *metaClass, +QString CppGenerator::destructorClassName(const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const { if (metaClass->isNamespace() || metaClass->hasPrivateDestructor()) @@ -6003,13 +6005,13 @@ QString CppGenerator::destructorClassName(const AbstractMetaClass *metaClass, } void CppGenerator::writeClassRegister(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext, const QString &signatures) const { ComplexTypeEntryCPtr classTypeEntry = metaClass->typeEntry(); - const AbstractMetaClass *enc = metaClass->targetLangEnclosingClass(); + AbstractMetaClassCPtr enc = metaClass->targetLangEnclosingClass(); QString enclosingObjectVariable = enc ? u"enclosingClass"_s : u"module"_s; QString pyTypeName = cpythonTypeName(metaClass); @@ -6126,8 +6128,8 @@ void CppGenerator::writeClassRegister(TextStream &s, } // Fill multiple inheritance data, if needed. - const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass); - if (miClass) { + const auto miClass = getMultipleInheritingClass(metaClass); + if (!miClass.isNull()) { s << "MultipleInheritanceInitFunction func = "; if (miClass == metaClass) { s << multipleInheritanceInitializerFunctionName(miClass) << ";\n"; @@ -6188,7 +6190,8 @@ void CppGenerator::writeClassRegister(TextStream &s, s << outdent << "}\n"; } -void CppGenerator::writeStaticFieldInitialization(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeStaticFieldInitialization(TextStream &s, + const AbstractMetaClassCPtr &metaClass) { s << "\nvoid " << getSimpleClassStaticFieldsInitFunctionName(metaClass) << "()\n{\n" << indent << "auto dict = reinterpret_cast<PyTypeObject *>(" @@ -6209,7 +6212,7 @@ enum class QtRegisterMetaType None, Pointer, Value }; -static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClass *c) +static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClassCPtr &c) { return c->typeEntry()->qtMetaTypeRegistration() != TypeSystem::QtMetaTypeRegistration::Unspecified; @@ -6218,7 +6221,7 @@ static bool hasQtMetaTypeRegistrationSpec(const AbstractMetaClass *c) // Returns if and how to register the Qt meta type. By default, "pointer" for // non-QObject object types and "value" for non-abstract, default-constructible // value types. -QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c) +QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClassCPtr &c) { if (c->isNamespace()) return QtRegisterMetaType::None; @@ -6237,7 +6240,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c) // Is there a "base" specification in some base class, meaning only the // base class is to be registered? - if (auto *base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec)) { + if (auto base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec); !base.isNull()) { const auto baseSpec = base->typeEntry()->qtMetaTypeRegistration(); if (baseSpec == TypeSystem::QtMetaTypeRegistration::BaseEnabled) return QtRegisterMetaType::None; @@ -6253,7 +6256,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClass *c) void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const GeneratorContext &context) { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); // Gets all class name variants used on different possible scopes QStringList nameVariants; if (!context.forSmartPointer()) @@ -6261,7 +6264,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const Generato else nameVariants << context.preciseType().cppSignature(); - const AbstractMetaClass *enclosingClass = metaClass->enclosingClass(); + AbstractMetaClassCPtr enclosingClass = metaClass->enclosingClass(); while (enclosingClass) { if (enclosingClass->typeEntry()->generateCode()) nameVariants << (enclosingClass->name() + u"::"_s + nameVariants.constLast()); @@ -6303,7 +6306,8 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(TextStream &s, const Generato } } -void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, + const AbstractMetaClassCPtr &metaClass) { QString polymorphicExpr = metaClass->typeEntry()->polymorphicIdValue(); @@ -6321,7 +6325,7 @@ void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaC << "return cptr;\n" << outdent; } else if (metaClass->isPolymorphic()) { const auto &ancestors = metaClass->allTypeSystemAncestors(); - for (auto *ancestor : ancestors) { + for (const auto &ancestor : ancestors) { if (ancestor->baseClass()) continue; if (ancestor->isPolymorphic()) { @@ -6342,7 +6346,8 @@ void CppGenerator::writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaC s << "return {};\n" << outdent << "}\n\n"; } -void CppGenerator::writeSetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass) const +void CppGenerator::writeSetattroDefinition(TextStream &s, + const AbstractMetaClassCPtr &metaClass) const { s << "static int " << ShibokenGenerator::cpythonSetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name, PyObject *value)\n{\n" << indent; @@ -6362,7 +6367,7 @@ void CppGenerator::writeSetattroFunction(TextStream &s, AttroCheck attroCheck, const GeneratorContext &context) const { Q_ASSERT(!context.forSmartPointer()); - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); writeSetattroDefinition(s, metaClass); // PYSIDE-1019: Switch tp_dict before doing tp_setattro. @@ -6420,7 +6425,7 @@ void CppGenerator::writeSmartPointerSetattroFunction(TextStream &s, writeSetattroDefaultReturn(s); } -void CppGenerator::writeGetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass) +void CppGenerator::writeGetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) { s << "static PyObject *" << cpythonGetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name)\n{\n" << indent; @@ -6443,7 +6448,7 @@ void CppGenerator::writeGetattroFunction(TextStream &s, AttroCheck attroCheck, const GeneratorContext &context) const { Q_ASSERT(!context.forSmartPointer()); - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); writeGetattroDefinition(s, metaClass); // PYSIDE-1019: Switch tp_dict before doing tp_getattro. @@ -6506,7 +6511,7 @@ void CppGenerator::writeSmartPointerGetattroFunction(TextStream &s, const BoolCastFunctionOptional &boolCast) { Q_ASSERT(context.forSmartPointer()); - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); writeGetattroDefinition(s, metaClass); s << "PyObject *tmp = PyObject_GenericGetAttr(self, name);\n" << "if (tmp)\n" << indent << "return tmp;\n" << outdent @@ -6632,7 +6637,7 @@ bool CppGenerator::finishGeneration() } AbstractMetaClassCList classesWithStaticFields; - for (auto cls : api().classes()){ + for (const auto &cls : api().classes()){ auto te = cls->typeEntry(); if (shouldGenerate(te)) { writeInitFunc(s_classInitDecl, s_classPythonDefines, @@ -6649,10 +6654,11 @@ bool CppGenerator::finishGeneration() // Initialize smart pointer types. for (const auto &smp : api().instantiatedSmartPointers()) { GeneratorContext context = contextForSmartPointer(smp.specialized, smp.type); - auto *enclosingClass = context.metaClass()->enclosingClass(); - auto enclosingTypeEntry = enclosingClass != nullptr - ? enclosingClass->typeEntry() - : targetLangEnclosingEntry(smp.type.typeEntry()); + const auto enclosingClass = context.metaClass()->enclosingClass(); + auto enclosingTypeEntry = enclosingClass.isNull() + ? targetLangEnclosingEntry(smp.type.typeEntry()) + : enclosingClass->typeEntry(); + writeInitFunc(s_classInitDecl, s_classPythonDefines, getInitFunctionName(context), enclosingTypeEntry); @@ -6713,7 +6719,7 @@ bool CppGenerator::finishGeneration() // Global enums AbstractMetaEnumList globalEnums = api().globalEnums(); - for (const AbstractMetaClass *nsp : invisibleTopNamespaces()) { + for (const auto &nsp : invisibleTopNamespaces()) { const auto oldSize = globalEnums.size(); nsp->getEnumsToBeGenerated(&globalEnums); if (globalEnums.size() > oldSize) @@ -6808,7 +6814,7 @@ bool CppGenerator::finishGeneration() TypeEntryCPtr externalType = it.key(); s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << '\n'; - for (const AbstractMetaClass *sourceClass : it.value()) { + for (const auto &sourceClass : it.value()) { AbstractMetaType sourceType = AbstractMetaType::fromAbstractMetaClass(sourceClass); AbstractMetaType targetType = AbstractMetaType::fromTypeEntry(externalType); writePythonToCppConversionFunctions(s, sourceType, targetType); @@ -6984,7 +6990,7 @@ bool CppGenerator::finishGeneration() // of the previously registered types (PYSIDE-1529). if (!classesWithStaticFields.isEmpty()) { s << "\n// Static field initialization\n"; - for (auto cls : std::as_const(classesWithStaticFields)) + for (const auto &cls : std::as_const(classesWithStaticFields)) s << getSimpleClassStaticFieldsInitFunctionName(cls) << "();\n"; } @@ -7038,8 +7044,8 @@ static bool useParentHeuristics(const ApiExtractorResult &api, { if (!ComplexTypeEntry::isParentManagementEnabled()) // FIXME PYSIDE 7: Remove this return true; - auto *owner = func->ownerClass(); - if (owner == nullptr) + const auto owner = func->ownerClass(); + if (owner.isNull()) return false; auto ownerEntry = parentManagementEntry(owner); if (ownerEntry.isNull()) @@ -7047,8 +7053,8 @@ static bool useParentHeuristics(const ApiExtractorResult &api, auto argTypeEntry = argType.typeEntry(); if (!argTypeEntry->isComplex()) return false; - auto *argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry); - return argClass != nullptr && parentManagementEntry(argClass) == ownerEntry; + const auto argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry); + return !argClass.isNull() && parentManagementEntry(argClass) == ownerEntry; } bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func, @@ -7156,7 +7162,7 @@ void CppGenerator::writeReturnValueHeuristics(TextStream &s, const AbstractMetaF void CppGenerator::writeHashFunction(TextStream &s, const GeneratorContext &context) const { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); const char hashType[] = "Py_hash_t"; s << "static " << hashType << ' ' << cpythonBaseName(metaClass) << "_HashFunc(PyObject *self)\n{\n" << indent; @@ -7180,7 +7186,7 @@ void CppGenerator::writeHashFunction(TextStream &s, const GeneratorContext &cont void CppGenerator::writeDefaultSequenceMethods(TextStream &s, const GeneratorContext &context) const { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); ErrorReturn errorReturn = ErrorReturn::Zero; // __len__ @@ -7251,7 +7257,7 @@ QString CppGenerator::writeReprFunction(TextStream &s, const GeneratorContext &context, uint indirections) const { - const AbstractMetaClass *metaClass = context.metaClass(); + const auto metaClass = context.metaClass(); QString funcName = cpythonBaseName(metaClass) + reprFunction(); s << "extern \"C\"\n{\n" << "static PyObject *" << funcName << "(PyObject *self)\n{\n" << indent; diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h index f16f5cce4..f38c14914 100644 --- a/sources/shiboken6/generator/shiboken/cppgenerator.h +++ b/sources/shiboken6/generator/shiboken/cppgenerator.h @@ -44,7 +44,7 @@ public: protected: QString fileNameForContext(const GeneratorContext &context) const override; static QList<AbstractMetaFunctionCList> - filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass, + filterGroupedOperatorFunctions(const AbstractMetaClassCPtr &metaClass, OperatorQueryOptions query); void generateClass(TextStream &s, const GeneratorContext &classContext) override; bool finishGeneration() override; @@ -98,11 +98,11 @@ private: const QString &flagsCppTypeName, const QString &enumTypeCheck) const; void writeEnumConverterFunctions(TextStream &s, const AbstractMetaEnum &metaEnum) const; - void writeConverterFunctions(TextStream &s, const AbstractMetaClass *metaClass, + void writeConverterFunctions(TextStream &s, const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const; void writeCustomConverterFunctions(TextStream &s, const CustomConversionPtr &customConversion) const; - void writeConverterRegister(TextStream &s, const AbstractMetaClass *metaClass, + void writeConverterRegister(TextStream &s, const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const; static void writeCustomConverterRegister(TextStream &s, const CustomConversionPtr &customConversion, @@ -179,15 +179,16 @@ private: static void writeTypeCheck(TextStream& s, const QSharedPointer<OverloadDataNode> &overloadData, const QString &argumentName); - static void writeTypeDiscoveryFunction(TextStream &s, const AbstractMetaClass *metaClass); + static void writeTypeDiscoveryFunction(TextStream &s, + const AbstractMetaClassCPtr &metaClass); - void writeSetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass) const; + void writeSetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) const; static void writeSetattroDefaultReturn(TextStream &s); void writeSmartPointerSetattroFunction(TextStream &s, const GeneratorContext &context) const; void writeSetattroFunction(TextStream &s, AttroCheck attroCheck, const GeneratorContext &context) const; - static void writeGetattroDefinition(TextStream &s, const AbstractMetaClass *metaClass); + static void writeGetattroDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass); static void writeSmartPointerGetattroFunction(TextStream &s, const GeneratorContext &context, const BoolCastFunctionOptional &boolCast); @@ -216,7 +217,7 @@ private: qsizetype writeArgumentConversion(TextStream &s, const AbstractMetaType &argType, const QString &argName, const QString &pyArgName, ErrorReturn errorReturn, - const AbstractMetaClass *context = nullptr, + const AbstractMetaClassCPtr &context = {}, const QString &defaultValue = QString(), bool castArgumentAsUnused = false) const; @@ -238,7 +239,7 @@ private: const AbstractMetaType &type, const QString &pyIn, const QString &cppOut, - const AbstractMetaClass *context = nullptr, + const AbstractMetaClassCPtr &context = {}, const QString &defaultValue = {}) const; /// Writes the conversion rule for arguments of regular and virtual methods. @@ -350,7 +351,7 @@ private: const AbstractMetaFunctionCPtr &func, int argIndex); /// Returns the class for an ownership modification of the argument. /// Throws if the argument is not a class or cannot be found. - static const AbstractMetaClass * + static AbstractMetaClassCPtr argumentClassFromIndex(const ApiExtractorResult &api, const AbstractMetaFunctionCPtr &func, int argIndex); @@ -360,22 +361,23 @@ private: ErrorReturn errorReturn) const; static QString getInitFunctionName(const GeneratorContext &context) ; - static QString getSimpleClassInitFunctionName(const AbstractMetaClass *metaClass) ; - static QString getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClass *metaClass); + static QString getSimpleClassInitFunctionName(const AbstractMetaClassCPtr &metaClass); + static QString + getSimpleClassStaticFieldsInitFunctionName(const AbstractMetaClassCPtr &metaClass); static void writeSignatureStrings(TextStream &s, const QString &signatures, const QString &arrayName, const char *comment); void writeClassRegister(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext, const QString &signatures) const; - QString destructorClassName(const AbstractMetaClass *metaClass, + QString destructorClassName(const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext) const; static void writeStaticFieldInitialization(TextStream &s, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); void writeClassDefinition(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &classContext); QByteArrayList methodDefinitionParameters(const OverloadData &overloadData) const; QList<PyMethodDefEntry> methodDefinitionEntries(const OverloadData &overloadData) const; @@ -384,22 +386,22 @@ private: QString signatureParameter(const AbstractMetaArgument &arg) const; /// Writes the implementation of all methods part of python sequence protocol void writeSequenceMethods(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &context) const; static void writeTypeAsSequenceDefinition(TextStream &s, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); /// Writes the PyMappingMethods structure for types that supports the python mapping protocol. static void writeTypeAsMappingDefinition(TextStream &s, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); void writeMappingMethods(TextStream &s, - const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass, const GeneratorContext &context) const; - void writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClass *metaClass) const; + void writeTypeAsNumberDefinition(TextStream &s, const AbstractMetaClassCPtr &metaClass) const; - static void writeTpTraverseFunction(TextStream &s, const AbstractMetaClass *metaClass); - static void writeTpClearFunction(TextStream &s, const AbstractMetaClass *metaClass); + static void writeTpTraverseFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass); + static void writeTpClearFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass); void writeCopyFunction(TextStream &s, const GeneratorContext &context) const; @@ -437,7 +439,7 @@ private: void writeEnumInitialization(TextStream &s, const AbstractMetaEnum &metaEnum, ErrorReturn errorReturn) const; - static void writeSignalInitialization(TextStream &s, const AbstractMetaClass *metaClass); + static void writeSignalInitialization(TextStream &s, const AbstractMetaClassCPtr &metaClass); static void writeFlagsMethods(TextStream &s, const AbstractMetaEnum &cppEnum); static void writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEnum); @@ -455,10 +457,13 @@ private: const QString &cppOpName, bool boolResult = false); - /// Writes the function that registers the multiple inheritance information for the classes that need it. - static void writeMultipleInheritanceInitializerFunction(TextStream &s, const AbstractMetaClass *metaClass); - /// Writes the implementation of special cast functions, used when we need to cast a class with multiple inheritance. - static void writeSpecialCastFunction(TextStream &s, const AbstractMetaClass *metaClass); + /// Writes the function that registers the multiple inheritance information + /// for the classes that need it. + static void writeMultipleInheritanceInitializerFunction(TextStream &s, + const AbstractMetaClassCPtr &metaClass); + /// Writes the implementation of special cast functions, used when we need + /// to cast a class with multiple inheritance. + static void writeSpecialCastFunction(TextStream &s, const AbstractMetaClassCPtr &metaClass); static void writePrimitiveConverterInitialization(TextStream &s, const CustomConversionPtr &customConversion); @@ -486,22 +491,22 @@ private: * \return name of the multiple inheritance information initializer function or * an empty string if there is no multiple inheritance in its ancestry. */ - static QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass); + static QString multipleInheritanceInitializerFunctionName(const AbstractMetaClassCPtr &metaClass); /// Returns a list of all classes to which the given class could be cast. - static QStringList getAncestorMultipleInheritance(const AbstractMetaClass *metaClass); + static QStringList getAncestorMultipleInheritance(const AbstractMetaClassCPtr &metaClass); /// Returns true if the given class supports the python number protocol - bool supportsNumberProtocol(const AbstractMetaClass *metaClass) const; + bool supportsNumberProtocol(const AbstractMetaClassCPtr &metaClass) const; /// Returns true if the given class supports the python sequence protocol - static bool supportsSequenceProtocol(const AbstractMetaClass *metaClass) ; + static bool supportsSequenceProtocol(const AbstractMetaClassCPtr &metaClass) ; /// Returns true if the given class supports the python mapping protocol - static bool supportsMappingProtocol(const AbstractMetaClass *metaClass) ; + static bool supportsMappingProtocol(const AbstractMetaClassCPtr &metaClass) ; /// Returns true if generator should produce getters and setters for the given class. - bool shouldGenerateGetSetList(const AbstractMetaClass *metaClass) const; + bool shouldGenerateGetSetList(const AbstractMetaClassCPtr &metaClass) const; void writeHashFunction(TextStream &s, const GeneratorContext &context) const; @@ -514,8 +519,8 @@ private: QString writeReprFunction(TextStream &s, const GeneratorContext &context, uint indirections) const; - BoolCastFunctionOptional boolCast(const AbstractMetaClass *metaClass) const; - bool hasBoolCast(const AbstractMetaClass *metaClass) const + BoolCastFunctionOptional boolCast(const AbstractMetaClassCPtr &metaClass) const; + bool hasBoolCast(const AbstractMetaClassCPtr &metaClass) const { return boolCast(metaClass).has_value(); } std::optional<AbstractMetaType> diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp index 57a542fe1..e93165398 100644 --- a/sources/shiboken6/generator/shiboken/headergenerator.cpp +++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp @@ -72,13 +72,14 @@ QString HeaderGenerator::fileNameForContext(const GeneratorContext &context) con return headerFileNameForContext(context); } -void HeaderGenerator::writeCopyCtor(TextStream &s, const AbstractMetaClass *metaClass) const +void HeaderGenerator::writeCopyCtor(TextStream &s, + const AbstractMetaClassCPtr &metaClass) const { s << wrapperName(metaClass) << "(const " << metaClass->qualifiedCppName() << "& self) : " << metaClass->qualifiedCppName() << "(self)\n{\n}\n\n"; } -static void writeProtectedEnums(TextStream &s, const AbstractMetaClass *metaClass) +static void writeProtectedEnums(TextStream &s, const AbstractMetaClassCPtr &metaClass) { const QString name = metaClass->qualifiedCppName(); for (const auto &e : metaClass->enums()) { @@ -90,7 +91,7 @@ static void writeProtectedEnums(TextStream &s, const AbstractMetaClass *metaClas void HeaderGenerator::generateClass(TextStream &s, const GeneratorContext &classContextIn) { GeneratorContext classContext = classContextIn; - const AbstractMetaClass *metaClass = classContext.metaClass(); + AbstractMetaClassCPtr metaClass = classContext.metaClass(); m_inheritedOverloads.clear(); // write license comment @@ -136,7 +137,7 @@ void HeaderGenerator::generateClass(TextStream &s, const GeneratorContext &class // Make protected enums accessible if (avoidProtectedHack()) { - recurseClassHierarchy(metaClass, [&s] (const AbstractMetaClass *metaClass) { + recurseClassHierarchy(metaClass, [&s] (const AbstractMetaClassCPtr &metaClass) { writeProtectedEnums(s, metaClass); return false; }); @@ -323,13 +324,13 @@ static inline void _writeTypeIndexValueLine(TextStream &s, } // Find equivalent typedefs "using Foo=QList<int>", "using Bar=QList<int>" -static const AbstractMetaClass * +static AbstractMetaClassCPtr findEquivalentTemplateTypedef(const AbstractMetaClassCList &haystack, - const AbstractMetaClass *needle) + const AbstractMetaClassCPtr &needle) { - auto *templateBaseClass = needle->templateBaseClass(); + auto templateBaseClass = needle->templateBaseClass(); const auto &instantiations = needle->templateBaseClassInstantiations(); - for (auto *candidate : haystack) { + for (const auto &candidate : haystack) { if (candidate->isTypeDef() && candidate->templateBaseClass() == templateBaseClass && candidate->templateBaseClassInstantiations() == instantiations) { @@ -374,7 +375,7 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR } void HeaderGenerator::writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { auto typeEntry = metaClass->typeEntry(); if (!typeEntry->generateCode()) @@ -417,18 +418,18 @@ static void formatTypeDefEntries(TextStream &s) // Helpers for forward-declaring classes in the module header for the // specialization of the SbkType template functions. This is possible if the // class does not have inner types or enums which need to be known. -static bool canForwardDeclare(const AbstractMetaClass *c) +static bool canForwardDeclare(const AbstractMetaClassCPtr &c) { if (c->isNamespace() || !c->enums().isEmpty() || !c->innerClasses().isEmpty() || c->isTypeDef()) { return false; } - if (auto *encl = c->enclosingClass()) + if (auto encl = c->enclosingClass(); !encl.isNull()) return encl->isNamespace(); return true; } -static void writeForwardDeclaration(TextStream &s, const AbstractMetaClass *c) +static void writeForwardDeclaration(TextStream &s, const AbstractMetaClassCPtr &c) { Q_ASSERT(!c->isNamespace()); const bool isStruct = c->attributes().testFlag(AbstractMetaClass::Struct); @@ -447,7 +448,7 @@ static void writeForwardDeclaration(TextStream &s, const AbstractMetaClass *c) // forward declarations to the module header. Ensure inline namespaces // are marked as such (else clang complains) and namespaces are ordered. struct NameSpace { - const AbstractMetaClass *nameSpace; + AbstractMetaClassCPtr nameSpace; AbstractMetaClassCList classes; }; @@ -458,7 +459,7 @@ static bool operator<(const NameSpace &n1, const NameSpace &n2) using NameSpaces = QList<NameSpace>; -static qsizetype indexOf(const NameSpaces &nsps, const AbstractMetaClass *needle) +static qsizetype indexOf(const NameSpaces &nsps, const AbstractMetaClassCPtr &needle) { for (qsizetype i = 0, count = nsps.size(); i < count; ++i) { if (nsps.at(i).nameSpace == needle) @@ -475,7 +476,7 @@ static void writeNamespaceForwardDeclarationRecursion(TextStream &s, qsizetype i if (root.nameSpace->isInlineNamespace()) s << "inline "; s << "namespace " << root.nameSpace->name() << " {\n" << indent; - for (auto *c : root.classes) + for (const auto &c : root.classes) writeForwardDeclaration(s, c); for (qsizetype i = 0, count = nameSpaces.size(); i < count; ++i) { @@ -490,15 +491,15 @@ static void writeForwardDeclarations(TextStream &s, { NameSpaces nameSpaces; - for (auto *c : classList) { - if (auto *encl = c->enclosingClass()) { + for (const auto &c : classList) { + if (auto encl = c->enclosingClass(); !encl.isNull()) { Q_ASSERT(encl->isNamespace()); auto idx = indexOf(nameSpaces, encl); if (idx != -1) { nameSpaces[idx].classes.append(c); } else { nameSpaces.append(NameSpace{encl, {c}}); - for (auto *enclNsp = encl->enclosingClass(); enclNsp != nullptr; + for (auto enclNsp = encl->enclosingClass(); !enclNsp.isNull(); enclNsp = enclNsp->enclosingClass()) { idx = indexOf(nameSpaces, enclNsp); if (idx == -1) @@ -546,11 +547,11 @@ bool HeaderGenerator::finishGeneration() auto classList = api().classes(); std::sort(classList.begin(), classList.end(), - [](const AbstractMetaClass *a, const AbstractMetaClass *b) { + [](const AbstractMetaClassCPtr &a, const AbstractMetaClassCPtr &b) { return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex(); }); - for (const AbstractMetaClass *metaClass : classList) + for (const auto &metaClass : classList) writeTypeIndexValueLines(macrosStream, api(), metaClass); for (const AbstractMetaEnum &metaEnum : api().globalEnums()) @@ -633,7 +634,7 @@ bool HeaderGenerator::finishGeneration() } StringStream protEnumsSurrogates(TextStream::Language::Cpp); - for (auto metaClass : classList) { + for (const auto &metaClass : classList) { const auto classType = metaClass->typeEntry(); if (!shouldGenerate(classType)) continue; @@ -811,7 +812,7 @@ void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum } } -void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) +void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass) { s << "template<> inline PyTypeObject *SbkType< ::" << cppClass->qualifiedCppName() << " >() " << "{ return reinterpret_cast<PyTypeObject *>(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n"; diff --git a/sources/shiboken6/generator/shiboken/headergenerator.h b/sources/shiboken6/generator/shiboken/headergenerator.h index f1735cd9f..92b6e94c4 100644 --- a/sources/shiboken6/generator/shiboken/headergenerator.h +++ b/sources/shiboken6/generator/shiboken/headergenerator.h @@ -30,16 +30,16 @@ protected: bool finishGeneration() override; private: - void writeCopyCtor(TextStream &s, const AbstractMetaClass *metaClass) const; + void writeCopyCtor(TextStream &s, const AbstractMetaClassCPtr &metaClass) const; void writeFunction(TextStream &s, const AbstractMetaFunctionCPtr &func, FunctionGeneration generation); void writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum &cppEnum) const; - static void writeSbkTypeFunction(TextStream &s, const AbstractMetaClass *cppClass) ; - static void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType) ; + static void writeSbkTypeFunction(TextStream &s, const AbstractMetaClassCPtr &cppClass); + static void writeSbkTypeFunction(TextStream &s, const AbstractMetaType &metaType); void writeTypeIndexValueLine(TextStream &s, const ApiExtractorResult &api, const TypeEntryCPtr &typeEntry); void writeTypeIndexValueLines(TextStream &s, const ApiExtractorResult &api, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); void writeProtectedEnumSurrogate(TextStream &s, const AbstractMetaEnum &cppEnum) const; void writeMemberFunctionWrapper(TextStream &s, const AbstractMetaFunctionCPtr &func, diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp index a5594791e..72bcc6562 100644 --- a/sources/shiboken6/generator/shiboken/overloaddata.cpp +++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp @@ -246,7 +246,7 @@ void OverloadDataRootNode::sortNextOverloads(const ApiExtractorResult &api) if (!metaClass) throw Exception(msgArgumentClassNotFound(m_overloads.constFirst(), te)); const auto &ancestors = metaClass->allTypeSystemAncestors(); - for (const AbstractMetaClass *ancestor : ancestors) { + for (const auto &ancestor : ancestors) { QString ancestorTypeName = ancestor->typeEntry()->name(); if (!graph.hasNode(ancestorTypeName)) continue; diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp index 32e871cd9..d2a05032e 100644 --- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp +++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp @@ -79,7 +79,7 @@ struct GeneratorClassInfoCacheEntry bool needsGetattroFunction = false; }; -using GeneratorClassInfoCache = QHash<const AbstractMetaClass *, GeneratorClassInfoCacheEntry>; +using GeneratorClassInfoCache = QHash<AbstractMetaClassCPtr, GeneratorClassInfoCacheEntry>; Q_GLOBAL_STATIC(GeneratorClassInfoCache, generatorClassInfoCache) @@ -163,7 +163,7 @@ const QHash<QString, QChar> &ShibokenGenerator::formatUnits() } QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType &cType, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, Options options) const { if (cType.isArray()) { @@ -180,7 +180,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType return translateType(cType, context, options); } -bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const +bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClassCPtr &metaClass) const { const auto wrapper = metaClass->cppWrapper(); return wrapper.testFlag(AbstractMetaClass::CppVirtualMethodWrapper) @@ -273,7 +273,7 @@ AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntry return result; } -QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const +QString ShibokenGenerator::wrapperName(const AbstractMetaClassCPtr &metaClass) const { Q_ASSERT(shouldGenerateCppWrapper(metaClass)); QString result = metaClass->name(); @@ -282,11 +282,11 @@ QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const return result + u"Wrapper"_s; } -QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClassCPtr &metaClass) { QString fullClassName = metaClass->name(); - const AbstractMetaClass *enclosing = metaClass->enclosingClass(); - while (enclosing) { + auto enclosing = metaClass->enclosingClass(); + while (!enclosing.isNull()) { if (NamespaceTypeEntry::isVisibleScope(enclosing->typeEntry())) fullClassName.prepend(enclosing->name() + u'.'); enclosing = enclosing->enclosingClass(); @@ -359,30 +359,30 @@ QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunctio + func->name(); } -QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass) + u"_getsetlist"_s; } -QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass) + u"_setattro"_s; } -QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass) + u"_getattro"_s; } QString ShibokenGenerator::cpythonGetterFunctionName(const QString &name, - const AbstractMetaClass *enclosingClass) + const AbstractMetaClassCPtr &enclosingClass) { return cpythonBaseName(enclosingClass) + QStringLiteral("_get_") + name; } QString ShibokenGenerator::cpythonSetterFunctionName(const QString &name, - const AbstractMetaClass *enclosingClass) + const AbstractMetaClassCPtr &enclosingClass) { return cpythonBaseName(enclosingClass) + QStringLiteral("_set_") + name; } @@ -398,13 +398,13 @@ QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField &me } QString ShibokenGenerator::cpythonGetterFunctionName(const QPropertySpec &property, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { return cpythonGetterFunctionName(property.name(), metaClass); } QString ShibokenGenerator::cpythonSetterFunctionName(const QPropertySpec &property, - const AbstractMetaClass *metaClass) + const AbstractMetaClassCPtr &metaClass) { return cpythonSetterFunctionName(property.name(), metaClass); } @@ -442,12 +442,12 @@ QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum) return flags.isNull() ? QString{} : cpythonFlagsName(flags); } -QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass->typeEntry()) + u"SpecialCastFunction"_s; } -QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass *metaClass, +QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClassCPtr &metaClass, const QString &argName) { return cpythonWrapperCPtr(metaClass->typeEntry(), argName); @@ -474,20 +474,21 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntryCPtr &type, } void ShibokenGenerator::writeToPythonConversion(TextStream & s, const AbstractMetaType &type, - const AbstractMetaClass * /* context */, + const AbstractMetaClassCPtr & /* context */, const QString &argumentName) { s << cpythonToPythonConversionFunction(type) << argumentName << ')'; } -void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaClass *metaClass, +void ShibokenGenerator::writeToCppConversion(TextStream &s, + const AbstractMetaClassCPtr &metaClass, const QString &inArgName, const QString &outArgName) { s << cpythonToCppConversionFunction(metaClass) << inArgName << ", &" << outArgName << ')'; } void ShibokenGenerator::writeToCppConversion(TextStream &s, const AbstractMetaType &type, - const AbstractMetaClass *context, const QString &inArgName, + const AbstractMetaClassCPtr &context, const QString &inArgName, const QString &outArgName) { s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')'; @@ -525,7 +526,7 @@ QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType &type) return cpythonBaseName(type.typeEntry()); } -QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClassCPtr &metaClass) { return cpythonBaseName(metaClass->typeEntry()); } @@ -569,7 +570,7 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntryCPtr &type) return baseName.replace(u"::"_s, u"_"_s); } -QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClassCPtr &metaClass) { return cpythonTypeName(metaClass->typeEntry()); } @@ -938,14 +939,14 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgume return cpythonIsConvertibleFunction(metaArg.type()); } -QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClassCPtr &metaClass) { return u"Shiboken::Conversions::pythonToCppPointer("_s + cpythonTypeNameExt(metaClass->typeEntry()) + u", "_s; } QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType &type, - const AbstractMetaClass * /* context */) + AbstractMetaClassCPtr /* context */) { if (type.isWrapperType()) { return u"Shiboken::Conversions::pythonToCpp"_s @@ -957,7 +958,7 @@ QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType } QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaType &type, - const AbstractMetaClass * /* context */) + AbstractMetaClassCPtr /* context */) { if (type.isWrapperType()) { QString conversion; @@ -981,7 +982,7 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT (type.isCString() || type.isVoidPointer()) ? QString() : u"&"_s); } -QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClassCPtr &metaClass) { return cpythonToPythonConversionFunction(metaClass->typeEntry()); } @@ -1062,7 +1063,7 @@ void ShibokenGenerator::writeFunctionArguments(TextStream &s, } } -GeneratorContext ShibokenGenerator::contextForClass(const AbstractMetaClass *c) const +GeneratorContext ShibokenGenerator::contextForClass(const AbstractMetaClassCPtr &c) const { GeneratorContext result = Generator::contextForClass(c); if (shouldGenerateCppWrapper(c)) { @@ -1151,7 +1152,7 @@ void ShibokenGenerator::writeFunctionCall(TextStream &s, ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverters() const { ExtendedConverterData extConvs; - for (auto metaClass : api().classes()) { + for (const auto &metaClass : api().classes()) { // Use only the classes for the current module. if (!shouldGenerate(metaClass->typeEntry())) continue; @@ -1735,12 +1736,13 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const GeneratorContext &con return func->injectedCodeContains(wrappedCtorCall); } -bool ShibokenGenerator::useOverrideCaching(const AbstractMetaClass *metaClass) +bool ShibokenGenerator::useOverrideCaching(const AbstractMetaClassCPtr &metaClass) { return metaClass->isPolymorphic(); } -ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(const AbstractMetaClass *metaClass) const +ShibokenGenerator::AttroCheck + ShibokenGenerator::checkAttroFunctionNeeds(const AbstractMetaClassCPtr &metaClass) const { AttroCheck result; if (metaClass->typeEntry()->isSmartPointer()) { @@ -1771,7 +1773,7 @@ ShibokenGenerator::AttroCheck ShibokenGenerator::checkAttroFunctionNeeds(const A return result; } -bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass) +bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClassCPtr &metaClass) { if (!metaClass) return false; @@ -1797,7 +1799,7 @@ bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass * } AbstractMetaFunctionCList - ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) + ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClassCPtr &metaClass) { AbstractMetaFunctionCList methods; if (metaClass) { @@ -1821,7 +1823,8 @@ AbstractMetaFunctionCList return methods; } -const AbstractMetaClass *ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass *metaClass) +AbstractMetaClassCPtr + ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClassCPtr &metaClass) { if (!metaClass || metaClass->baseClassNames().isEmpty()) return nullptr; @@ -1845,7 +1848,7 @@ QString ShibokenGenerator::getPrivateModuleHeaderFileName(const QString &moduleN return getModuleHeaderFileBaseName(moduleName) + QStringLiteral("_p.h"); } -IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClass *metaClass) const +IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClassCPtr &metaClass) const { IncludeGroupList result; const auto typeEntry = metaClass->typeEntry(); @@ -1861,8 +1864,8 @@ IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClass *metaC const auto implicitConvs = implicitConversions(typeEntry); for (auto &f : implicitConvs) { if (f->isConversionOperator()) { - auto *source = f->ownerClass(); - Q_ASSERT(source); + const auto source = f->ownerClass(); + Q_ASSERT(!source.isNull()); result.back().append(source->typeEntry()->include()); } } @@ -1917,12 +1920,13 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getGlobalFunctionGroups() c { FunctionGroups results; insertIntoFunctionGroups(api().globalFunctions(), &results); - for (auto nsp : invisibleTopNamespaces()) + for (const auto &nsp : invisibleTopNamespaces()) insertIntoFunctionGroups(nsp->functions(), &results); return results; } -const GeneratorClassInfoCacheEntry &ShibokenGenerator::getGeneratorClassInfo(const AbstractMetaClass *scope) +const GeneratorClassInfoCacheEntry & + ShibokenGenerator::getGeneratorClassInfo(const AbstractMetaClassCPtr &scope) { auto cache = generatorClassInfoCache(); auto it = cache->find(scope); @@ -1934,7 +1938,8 @@ const GeneratorClassInfoCacheEntry &ShibokenGenerator::getGeneratorClassInfo(con return it.value(); } -ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroups(const AbstractMetaClass *scope) +ShibokenGenerator::FunctionGroups + ShibokenGenerator::getFunctionGroups(const AbstractMetaClassCPtr &scope) { Q_ASSERT(scope); return getGeneratorClassInfo(scope).functionGroups; @@ -1957,7 +1962,8 @@ static void removeConstOverloads(AbstractMetaFunctionCList *overloads) } } -ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaClass *scope) +ShibokenGenerator::FunctionGroups + ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaClassCPtr &scope) { AbstractMetaFunctionCList lst = scope->functions(); scope->getFunctionsFromInvisibleNamespacesToBeGenerated(&lst); @@ -1994,7 +2000,7 @@ static bool hidesBaseClassFunctions(const AbstractMetaFunctionCPtr &f) & (AbstractMetaFunction::OverriddenCppMethod | AbstractMetaFunction::FinalCppMethod)); } -void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope, +void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClassCPtr &scope, AbstractMetaFunctionCList *overloads) { if (overloads->isEmpty() || scope->isNamespace() || scope->baseClasses().isEmpty()) @@ -2020,7 +2026,8 @@ void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope, AbstractMetaFunctionCList baseCandidates; - auto basePredicate = [&functionName, &seenSignatures, &baseCandidates](const AbstractMetaClass *b) { + auto basePredicate = [&functionName, &seenSignatures, &baseCandidates] + (const AbstractMetaClassCPtr &b) { for (const auto &f : b->functions()) { if (f->generateBinding() && f->name() == functionName) { const QString signature = f->minimalSignature(); @@ -2033,7 +2040,7 @@ void ShibokenGenerator::getInheritedOverloads(const AbstractMetaClass *scope, return false; // Keep going }; - for (const auto *baseClass : scope->baseClasses()) + for (const auto &baseClass : scope->baseClasses()) recurseClassHierarchy(baseClass, basePredicate); // Remove the ones that are not made visible with using declarations @@ -2194,10 +2201,11 @@ static void appendIndexSuffix(QString *s) s->append(QStringLiteral("IDX")); } -QString ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const AbstractMetaClass *metaClass) +QString + ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const AbstractMetaClassCPtr &metaClass) { - const AbstractMetaClass *templateBaseClass = metaClass->templateBaseClass(); - Q_ASSERT(templateBaseClass); + const auto templateBaseClass = metaClass->templateBaseClass(); + Q_ASSERT(!templateBaseClass.isNull()); QString result = u"SBK_"_s + _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName()).toUpper(); for (const auto &instantiation : metaClass->templateBaseClassInstantiations()) @@ -2206,7 +2214,7 @@ QString ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const Abstr return result; } -QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass *metaClass) +QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClassCPtr &metaClass) { return getTypeIndexVariableName(metaClass->typeEntry()); } @@ -2290,8 +2298,8 @@ QString ShibokenGenerator::pythonArgsAt(int i) void ShibokenGenerator::replaceTemplateVariables(QString &code, const AbstractMetaFunctionCPtr &func) const { - const AbstractMetaClass *cpp_class = func->ownerClass(); - if (cpp_class) + const auto cpp_class = func->ownerClass(); + if (!cpp_class.isNull()) code.replace(u"%TYPE"_s, cpp_class->name()); const AbstractMetaArgumentList &argument = func->arguments(); diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.h b/sources/shiboken6/generator/shiboken/shibokengenerator.h index d0b1158c6..13e9bee06 100644 --- a/sources/shiboken6/generator/shiboken/shibokengenerator.h +++ b/sources/shiboken6/generator/shiboken/shibokengenerator.h @@ -83,7 +83,7 @@ public: protected: bool doSetup() override; - GeneratorContext contextForClass(const AbstractMetaClass *c) const override; + GeneratorContext contextForClass(const AbstractMetaClassCPtr &c) const override; /** * Returns a map with all functions grouped, the function name is used as key. @@ -91,7 +91,7 @@ protected: * \param scope Where to search for functions, null means all global functions. */ FunctionGroups getGlobalFunctionGroups() const; - static FunctionGroups getFunctionGroups(const AbstractMetaClass *scope); + static FunctionGroups getFunctionGroups(const AbstractMetaClassCPtr &scope); /** * Returns all different inherited overloads of func, and includes func as well. @@ -148,34 +148,38 @@ protected: int arg_count = -1) const; /// Returns the top-most class that has multiple inheritance in the ancestry. - static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass *metaClass); + static AbstractMetaClassCPtr + getMultipleInheritingClass(const AbstractMetaClassCPtr &metaClass); - static bool useOverrideCaching(const AbstractMetaClass *metaClass); - AttroCheck checkAttroFunctionNeeds(const AbstractMetaClass *metaClass) const; + static bool useOverrideCaching(const AbstractMetaClassCPtr &metaClass); + AttroCheck checkAttroFunctionNeeds(const AbstractMetaClassCPtr &metaClass) const; - /// Returns a list of methods of the given class where each one is part of a different overload with both static and non-static method. + /// Returns a list of methods of the given class where each one is part of + /// a different overload with both static and non-static method. static AbstractMetaFunctionCList - getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass); + getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClassCPtr &metaClass); static void writeToPythonConversion(TextStream &s, const AbstractMetaType &type, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, const QString &argumentName); static void writeToCppConversion(TextStream &s, const AbstractMetaType &type, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, const QString &inArgName, const QString &outArgName); static void writeToCppConversion(TextStream &s, - const AbstractMetaClass *metaClass, const QString &inArgName, + const AbstractMetaClassCPtr &metaClass, + const QString &inArgName, const QString &outArgName); /// Returns true if the argument is a pointer that rejects nullptr values. static bool shouldRejectNullPointerArgument(const AbstractMetaFunctionCPtr &func, int argIndex); - /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper. - bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const; + /// Verifies if the class should have a C++ wrapper generated for it, + /// instead of only a Python wrapper. + bool shouldGenerateCppWrapper(const AbstractMetaClassCPtr &metaClass) const; /// Returns which functions need to be generated into the wrapper class FunctionGeneration functionGeneration(const AbstractMetaFunctionCPtr &func) const; @@ -183,9 +187,9 @@ protected: // Return a list of implicit conversions if generation is enabled. AbstractMetaFunctionCList implicitConversions(const TypeEntryCPtr &t) const; - QString wrapperName(const AbstractMetaClass *metaClass) const; + QString wrapperName(const AbstractMetaClassCPtr &metaClass) const; - static QString fullPythonClassName(const AbstractMetaClass *metaClass); + static QString fullPythonClassName(const AbstractMetaClassCPtr &metaClass); static QString fullPythonFunctionName(const AbstractMetaFunctionCPtr &func, bool forceFunc); bool wrapperDiagnostics() const { return m_wrapperDiagnostics; } @@ -211,10 +215,10 @@ protected: static QString converterObject(const AbstractMetaType &type) ; static QString converterObject(const TypeEntryCPtr &type); - static QString cpythonBaseName(const AbstractMetaClass *metaClass); + static QString cpythonBaseName(const AbstractMetaClassCPtr &metaClass); static QString cpythonBaseName(const TypeEntryCPtr &type); static QString cpythonBaseName(const AbstractMetaType &type); - static QString cpythonTypeName(const AbstractMetaClass *metaClass); + static QString cpythonTypeName(const AbstractMetaClassCPtr &metaClass); static QString cpythonTypeName(const TypeEntryCPtr &type); static QString cpythonTypeNameExt(const TypeEntryCPtr &type); static QString cpythonTypeNameExt(const AbstractMetaType &type) ; @@ -224,26 +228,26 @@ protected: static QString cpythonIsConvertibleFunction(AbstractMetaType metaType); static QString cpythonIsConvertibleFunction(const AbstractMetaArgument &metaArg); - static QString cpythonToCppConversionFunction(const AbstractMetaClass *metaClass) ; + static QString cpythonToCppConversionFunction(const AbstractMetaClassCPtr &metaClass) ; static QString cpythonToCppConversionFunction(const AbstractMetaType &type, - const AbstractMetaClass *context = nullptr); + AbstractMetaClassCPtr context = {}); static QString cpythonToPythonConversionFunction(const AbstractMetaType &type, - const AbstractMetaClass *context = nullptr); - static QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass); + AbstractMetaClassCPtr context = {}); + static QString cpythonToPythonConversionFunction(const AbstractMetaClassCPtr &metaClass); static QString cpythonToPythonConversionFunction(const TypeEntryCPtr &type); static QString cpythonFunctionName(const AbstractMetaFunctionCPtr &func) ; static QString cpythonMethodDefinitionName(const AbstractMetaFunctionCPtr &func); - static QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass); - static QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass); - static QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass); + static QString cpythonGettersSettersDefinitionName(const AbstractMetaClassCPtr &metaClass); + static QString cpythonGetattroFunctionName(const AbstractMetaClassCPtr &metaClass); + static QString cpythonSetattroFunctionName(const AbstractMetaClassCPtr &metaClass); static QString cpythonGetterFunctionName(const AbstractMetaField &metaField); static QString cpythonSetterFunctionName(const AbstractMetaField &metaField); static QString cpythonGetterFunctionName(const QPropertySpec &property, - const AbstractMetaClass *metaClass); + const AbstractMetaClassCPtr &metaClass); static QString cpythonSetterFunctionName(const QPropertySpec &property, - const AbstractMetaClass *metaClass); - static QString cpythonWrapperCPtr(const AbstractMetaClass *metaClass, + const AbstractMetaClassCPtr &metaClass); + static QString cpythonWrapperCPtr(const AbstractMetaClassCPtr &metaClass, const QString &argName = QStringLiteral("self")); static QString cpythonWrapperCPtr(const AbstractMetaType &metaType, const QString &argName); @@ -254,15 +258,17 @@ protected: static QString cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry); static QString cpythonFlagsName(const AbstractMetaEnum *metaEnum); - /// Returns the special cast function name, the function used to proper cast class with multiple inheritance. - static QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass); + /// Returns the special cast function name, the function used to proper cast + /// class with multiple inheritance. + static QString cpythonSpecialCastFunctionName(const AbstractMetaClassCPtr &metaClass); - /// Returns the file name for the module global header. If no module name is provided the current will be used. + /// Returns the file name for the module global header. If no module name + /// is provided the current will be used. static QString getModuleHeaderFileName(const QString &moduleName = QString()); static QString getPrivateModuleHeaderFileName(const QString &moduleName = QString()); /// Includes for header (native wrapper class) or binding source - QList<IncludeGroup> classIncludes(const AbstractMetaClass *metaClass) const; + QList<IncludeGroup> classIncludes(const AbstractMetaClassCPtr &metaClass) const; OptionDescriptions options() const override; bool handleOption(const QString &key, const QString &value) override; @@ -283,10 +289,10 @@ protected: static QString pythonModuleObjectName(const QString &moduleName = QString()); static QString convertersVariableName(const QString &moduleName = QString()); /// Returns the type index variable name for a given class. - static QString getTypeIndexVariableName(const AbstractMetaClass *metaClass); + static QString getTypeIndexVariableName(const AbstractMetaClassCPtr &metaClass); /// Returns the type index variable name for a given typedef for a template /// class instantiation made of the template class and the instantiation values - static QString getTypeAlternateTemplateIndexVariableName(const AbstractMetaClass *metaClass); + static QString getTypeAlternateTemplateIndexVariableName(const AbstractMetaClassCPtr &metaClass); static QString getTypeIndexVariableName(TypeEntryCPtr type); static QString getTypeIndexVariableName(const AbstractMetaType &type) ; @@ -324,16 +330,17 @@ protected: private: static QString getModuleHeaderFileBaseName(const QString &moduleName = QString()); static QString cpythonGetterFunctionName(const QString &name, - const AbstractMetaClass *enclosingClass); + const AbstractMetaClassCPtr &enclosingClass); static QString cpythonSetterFunctionName(const QString &name, - const AbstractMetaClass *enclosingClass); + const AbstractMetaClassCPtr &enclosingClass); - static const GeneratorClassInfoCacheEntry &getGeneratorClassInfo(const AbstractMetaClass *scope); - static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClass *scope); - static bool classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass); + static const GeneratorClassInfoCacheEntry & + getGeneratorClassInfo(const AbstractMetaClassCPtr &scope); + static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClassCPtr &scope); + static bool classNeedsGetattroFunctionImpl(const AbstractMetaClassCPtr &metaClass); QString translateTypeForWrapperMethod(const AbstractMetaType &cType, - const AbstractMetaClass *context, + const AbstractMetaClassCPtr &context, Options opt = NoOption) const; /** @@ -342,7 +349,7 @@ private: * \param func the metafunction to be searched in subclasses. * \param seen the function's minimal signatures already seen. */ - static void getInheritedOverloads(const AbstractMetaClass *scope, + static void getInheritedOverloads(const AbstractMetaClassCPtr &scope, AbstractMetaFunctionCList *overloads); |