diff options
Diffstat (limited to 'sources/shiboken6/ApiExtractor')
38 files changed, 368 insertions, 373 deletions
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp index 33eb85ace..686a28993 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp @@ -72,7 +72,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() : AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate() { - qDeleteAll(m_globalFunctions); qDeleteAll(m_templates); qDeleteAll(m_smartPointers); qDeleteAll(m_metaClasses); @@ -103,7 +102,7 @@ const AbstractMetaClassList &AbstractMetaBuilder::smartPointers() const return d->m_smartPointers; } -const AbstractMetaFunctionList &AbstractMetaBuilder::globalFunctions() const +const AbstractMetaFunctionCList &AbstractMetaBuilder::globalFunctions() const { return d->m_globalFunctions; } @@ -152,10 +151,9 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() if (!clazz) continue; - const AbstractMetaFunctionList functions = clazz->functions(); bool found = false; QStringList possibleSignatures; - for (AbstractMetaFunction *function : functions) { + for (const auto &function : clazz->functions()) { if (function->implementingClass() == clazz && modification.matches(function->minimalSignature())) { found = true; @@ -172,7 +170,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() qCWarning(lcShiboken).noquote().nospace() << msgNoFunctionForModification(clazz, signature, modification.originalSignature(), - possibleSignatures, functions); + possibleSignatures, clazz->functions()); } } } @@ -290,7 +288,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte metaFunction->setVisibility(AbstractMetaFunction::Public); metaFunction->setOriginalAttributes(metaFunction->attributes()); setupFunctionDefaults(metaFunction, baseoperandClass); - baseoperandClass->addFunction(metaFunction); + baseoperandClass->addFunction(AbstractMetaFunctionCPtr(metaFunction)); Q_ASSERT(!metaFunction->wasPrivate()); } else { delete metaFunction; @@ -338,7 +336,7 @@ void AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem } setupFunctionDefaults(streamFunction, funcClass); - funcClass->addFunction(streamFunction); + funcClass->addFunction(AbstractMetaFunctionCPtr(streamFunction)); if (funcClass == streamClass) funcClass->typeEntry()->addExtraInclude(streamedClass->typeEntry()->include()); else @@ -449,10 +447,9 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) if (!metaFunc) continue; - if (!funcEntry->hasSignature(metaFunc->minimalSignature())) { - delete metaFunc; + AbstractMetaFunctionCPtr metaFuncPtr(metaFunc); + if (!funcEntry->hasSignature(metaFunc->minimalSignature())) continue; - } applyFunctionModifications(metaFunc); @@ -461,7 +458,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) delete metaFunc->typeEntry(); metaFunc->setTypeEntry(funcEntry); - m_globalFunctions << metaFunc; + m_globalFunctions << metaFuncPtr; } ReportHandler::startProgress("Fixing class inheritance..."); @@ -509,7 +506,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) const QStringList &signatures = fte->signatures(); for (const QString &signature : signatures) { bool ok = false; - for (AbstractMetaFunction *func : qAsConst(m_globalFunctions)) { + for (const auto &func : qAsConst(m_globalFunctions)) { if (signature == func->minimalSignature()) { ok = true; break; @@ -612,13 +609,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) // Functions added to the module on the type system. const AddedFunctionList &globalUserFunctions = types->globalUserFunctions(); for (const AddedFunctionPtr &addedFunc : globalUserFunctions) { - AbstractMetaFunction *metaFunc = traverseFunction(addedFunc); - if (Q_UNLIKELY(!metaFunc)) { + if (!traverseAddedGlobalFunction(addedFunc)) { qFatal("Unable to traverse added global function \"%s\".", qPrintable(addedFunc->name())); } - metaFunc->setFunctionType(AbstractMetaFunction::NormalFunction); - m_globalFunctions << metaFunc; } m_itemToClass.clear(); @@ -633,7 +627,7 @@ static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2) { return c1->fullName() < c2->fullName(); } -static bool metaFunctionLessThan(const AbstractMetaFunction *f1, const AbstractMetaFunction *f2) +static bool metaFunctionLessThan(const AbstractMetaFunctionCPtr &f1, const AbstractMetaFunctionCPtr &f2) { return f1->name() < f2->name(); } bool AbstractMetaBuilder::build(const QByteArrayList &arguments, @@ -1233,12 +1227,13 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF metaFunction->setType(metaType); } -AbstractMetaFunctionList AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem, - AbstractMetaClass::Attributes *constructorAttributes, - AbstractMetaClass *currentClass) +AbstractMetaFunctionRawPtrList + AbstractMetaBuilderPrivate::classFunctionList(const ScopeModelItem &scopeItem, + AbstractMetaClass::Attributes *constructorAttributes, + AbstractMetaClass *currentClass) { *constructorAttributes = {}; - AbstractMetaFunctionList result; + AbstractMetaFunctionRawPtrList result; const FunctionList &scopeFunctionList = scopeItem->functions(); result.reserve(scopeFunctionList.size()); for (const FunctionModelItem &function : scopeFunctionList) { @@ -1258,7 +1253,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem, AbstractMetaClass *metaClass) { AbstractMetaAttributes::Attributes constructorAttributes; - const AbstractMetaFunctionList functions = + const AbstractMetaFunctionRawPtrList functions = classFunctionList(scopeItem, &constructorAttributes, metaClass); metaClass->setAttributes(metaClass->attributes() | constructorAttributes); @@ -1325,7 +1320,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem, if (metaFunction->isConversionOperator()) fixReturnTypeOfConversionOperator(metaFunction); - metaClass->addFunction(metaFunction); + metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction)); applyFunctionModifications(metaFunction); } else if (metaFunction->isDestructor()) { metaClass->setHasPrivateDestructor(metaFunction->isPrivate()); @@ -1346,7 +1341,7 @@ void AbstractMetaBuilderPrivate::fillAddedFunctions(AbstractMetaClass *metaClass // Add the functions added by the typesystem const AddedFunctionList &addedFunctions = metaClass->typeEntry()->addedFunctions(); for (const AddedFunctionPtr &addedFunc : addedFunctions) { - if (!traverseFunction(addedFunc, metaClass)) { + if (!traverseAddedMemberFunction(addedFunc, metaClass)) { qFatal("Unable to traverse function \"%s\" added to \"%s\".", qPrintable(addedFunc->name()), qPrintable(metaClass->name())); } @@ -1496,13 +1491,19 @@ static void applyDefaultExpressionModifications(const FunctionModificationList & } } -AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFunctionPtr &addedFunc) +bool AbstractMetaBuilderPrivate::traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc) { - return traverseFunction(addedFunc, nullptr); + AbstractMetaFunction *metaFunction = traverseAddedFunctionHelper(addedFunc); + if (metaFunction == nullptr) + return false; + metaFunction->setFunctionType(AbstractMetaFunction::NormalFunction); + m_globalFunctions << AbstractMetaFunctionCPtr(metaFunction); + return true; } -AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass) +AbstractMetaFunction * + AbstractMetaBuilderPrivate::traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc, + AbstractMetaClass *metaClass) { QString errorMessage; @@ -1581,35 +1582,42 @@ AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFu if (!metaArguments.isEmpty()) fixArgumentNames(metaFunction, metaFunction->modifications(metaClass)); - if (metaClass) { - const AbstractMetaArgumentList fargs = metaFunction->arguments(); - if (metaClass->isNamespace()) - *metaFunction += AbstractMetaFunction::Static; - if (metaFunction->name() == metaClass->name()) { - metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction); - if (fargs.size() == 1) { - const TypeEntry *te = fargs.constFirst().type().typeEntry(); - if (te->isCustom()) - metaFunction->setExplicit(true); - if (te->name() == metaFunction->name()) - metaFunction->setFunctionType(AbstractMetaFunction::CopyConstructorFunction); - } - } else { - auto type = AbstractMetaFunction::NormalFunction; - if (metaFunction->name() == QLatin1String("__getattro__")) - type = AbstractMetaFunction::GetAttroFunction; - else if (metaFunction->name() == QLatin1String("__setattro__")) - type = AbstractMetaFunction::SetAttroFunction; - metaFunction->setFunctionType(type); - } + return metaFunction; +} + +bool AbstractMetaBuilderPrivate::traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc, + AbstractMetaClass *metaClass) +{ + AbstractMetaFunction *metaFunction = traverseAddedFunctionHelper(addedFunc, metaClass); + if (metaFunction == nullptr) + return false; - metaFunction->setDeclaringClass(metaClass); - metaFunction->setImplementingClass(metaClass); - metaClass->addFunction(metaFunction); - metaClass->setHasNonPrivateConstructor(true); + const AbstractMetaArgumentList fargs = metaFunction->arguments(); + if (metaClass->isNamespace()) + *metaFunction += AbstractMetaFunction::Static; + if (metaFunction->name() == metaClass->name()) { + metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction); + if (fargs.size() == 1) { + const TypeEntry *te = fargs.constFirst().type().typeEntry(); + if (te->isCustom()) + metaFunction->setExplicit(true); + if (te->name() == metaFunction->name()) + metaFunction->setFunctionType(AbstractMetaFunction::CopyConstructorFunction); + } + } else { + auto type = AbstractMetaFunction::NormalFunction; + if (metaFunction->name() == QLatin1String("__getattro__")) + type = AbstractMetaFunction::GetAttroFunction; + else if (metaFunction->name() == QLatin1String("__setattro__")) + type = AbstractMetaFunction::SetAttroFunction; + metaFunction->setFunctionType(type); } - return metaFunction; + metaFunction->setDeclaringClass(metaClass); + metaFunction->setImplementingClass(metaClass); + metaClass->addFunction(AbstractMetaFunctionCPtr(metaFunction)); + metaClass->setHasNonPrivateConstructor(true); + return true; } void AbstractMetaBuilderPrivate::fixArgumentNames(AbstractMetaFunction *func, const FunctionModificationList &mods) @@ -2640,10 +2648,10 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub } const auto &templateTypes = subclass->templateBaseClassInstantiations(); - const AbstractMetaFunctionList existingSubclassFuncs = + const AbstractMetaFunctionCList existingSubclassFuncs = subclass->functions(); // Take copy - const AbstractMetaFunctionList &templateClassFunctions = templateClass->functions(); - for (const AbstractMetaFunction *function : templateClassFunctions) { + const auto &templateClassFunctions = templateClass->functions(); + for (const auto &function : templateClassFunctions) { // If the function is modified or the instantiation has an equally named // function we have shadowing, so we need to skip it. if (function->isModifiedRemoved(TypeSystem::All) @@ -2721,7 +2729,7 @@ void AbstractMetaBuilderPrivate::inheritTemplateFunctions(AbstractMetaClass *sub qPrintable(subclass->name()), qPrintable(templateClass->name()), qPrintable(errorMessage)); } - subclass->addFunction(f.release()); + subclass->addFunction(AbstractMetaFunctionCPtr(f.release())); } // Take copy @@ -2786,17 +2794,14 @@ void AbstractMetaBuilderPrivate::parseQ_Properties(AbstractMetaClass *metaClass, } } -static AbstractMetaFunction* findCopyCtor(AbstractMetaClass* cls) +static AbstractMetaFunctionCPtr findCopyCtor(AbstractMetaClass* cls) { - - const auto &functions = cls->functions(); - - for (AbstractMetaFunction *f : qAsConst(functions)) { + for (const auto &f : cls->functions()) { const AbstractMetaFunction::FunctionType t = f->functionType(); if (t == AbstractMetaFunction::CopyConstructorFunction || t == AbstractMetaFunction::AssignmentOperatorFunction) return f; } - return nullptr; + return {}; } void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls) @@ -2804,8 +2809,8 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls) bool result = true; // find copy ctor for the current class - AbstractMetaFunction* copyCtor = findCopyCtor(cls); - if (copyCtor) { // if exists a copy ctor in this class + auto copyCtor = findCopyCtor(cls); + if (!copyCtor.isNull()) { // if exists a copy ctor in this class result = copyCtor->isPublic(); } else { // else... lets find one in the parent class QQueue<AbstractMetaClass*> baseClasses; @@ -2829,8 +2834,8 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls) void AbstractMetaBuilderPrivate::setupExternalConversion(AbstractMetaClass *cls) { - const AbstractMetaFunctionList &convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp); - for (AbstractMetaFunction *func : convOps) { + const auto &convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp); + for (const auto &func : convOps) { if (func->isModifiedRemoved()) continue; AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type().typeEntry()); @@ -2981,8 +2986,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const graph.addEdge(baseIt.value(), classIndex); } - const AbstractMetaFunctionList &functions = clazz->functions(); - for (AbstractMetaFunction *func : functions) { + for (const auto &func : clazz->functions()) { const AbstractMetaArgumentList &arguments = func->arguments(); for (const AbstractMetaArgument &arg : arguments) { // Check methods with default args: If a class is instantiated by value, diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h index 45459a16e..cd9f36ca9 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h @@ -68,7 +68,7 @@ public: const AbstractMetaClassList &classes() const; const AbstractMetaClassList &templates() const; const AbstractMetaClassList &smartPointers() const; - const AbstractMetaFunctionList &globalFunctions() const; + const AbstractMetaFunctionCList &globalFunctions() const; const AbstractMetaEnumList &globalEnums() const; std::optional<AbstractMetaEnum> findEnum(const TypeEntry *typeEntry) const; diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h index 0fe66fe38..1dc1dd3d7 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h @@ -97,12 +97,9 @@ public: const QSet<QString> &enumsDeclarations); void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent, const QStringList &enumsDeclarations); - AbstractMetaFunctionList classFunctionList(const ScopeModelItem &scopeItem, - AbstractMetaClass::Attributes *constructorAttributes, - AbstractMetaClass *currentClass); - AbstractMetaFunctionList templateClassFunctionList(const ScopeModelItem &scopeItem, - AbstractMetaClass *metaClass, - bool *constructorRejected); + AbstractMetaFunctionRawPtrList classFunctionList(const ScopeModelItem &scopeItem, + AbstractMetaClass::Attributes *constructorAttributes, + AbstractMetaClass *currentClass); void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent); void applyFunctionModifications(AbstractMetaFunction* func); void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent); @@ -110,9 +107,11 @@ public: AbstractMetaClass *currentClass); void traverseOperatorFunction(const FunctionModelItem &item, AbstractMetaClass *currentClass); - AbstractMetaFunction* traverseFunction(const AddedFunctionPtr &addedFunc); - AbstractMetaFunction* traverseFunction(const AddedFunctionPtr &addedFunc, - AbstractMetaClass *metaClass); + AbstractMetaFunction *traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc, + AbstractMetaClass *metaClass = nullptr); + bool traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc); + bool traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc, + AbstractMetaClass *metaClass); AbstractMetaFunction *traverseFunction(const FunctionModelItem &function, AbstractMetaClass *currentClass); std::optional<AbstractMetaField> traverseField(const VariableModelItem &field, @@ -193,7 +192,7 @@ public: AbstractMetaClassList m_templates; AbstractMetaClassList m_smartPointers; QHash<const _CodeModelItem *, AbstractMetaClass *> m_itemToClass; - AbstractMetaFunctionList m_globalFunctions; + AbstractMetaFunctionCList m_globalFunctions; AbstractMetaEnumList m_globalEnums; using RejectMap = QMap<QString, AbstractMetaBuilder::RejectReason>; diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp index 79c542f26..df0ce2a1c 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp @@ -1108,11 +1108,15 @@ QString AbstractMetaFunction::modifiedName() const return d->modifiedName(this); } -AbstractMetaFunction * -AbstractMetaFunction::find(const AbstractMetaFunctionList &haystack, +AbstractMetaFunctionCPtr +AbstractMetaFunction::find(const AbstractMetaFunctionCList &haystack, const QString &needle) { - return findByName(haystack, needle); + for (const auto &f : haystack) { + if (f->name() == needle) + return f; + } + return {}; } void AbstractMetaFunction::setAllowThreadModification(TypeSystem::AllowThread am) diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h index 2db47daeb..9628224af 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h +++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h @@ -276,8 +276,8 @@ public: bool isCallOperator() const; - static AbstractMetaFunction * - find(const AbstractMetaFunctionList &haystack, const QString &needle); + static AbstractMetaFunctionCPtr + find(const AbstractMetaFunctionCList &haystack, const QString &needle); // for the meta builder only void setAllowThreadModification(TypeSystem::AllowThread am); diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp index bdddfed6e..4b923309e 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp @@ -42,7 +42,7 @@ #include <QtCore/QDebug> -bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b) +bool function_sorter(const AbstractMetaFunctionCPtr &a, const AbstractMetaFunctionCPtr &b) { return a->signature() < b->signature(); } @@ -68,11 +68,6 @@ public: { } - ~AbstractMetaClassPrivate() - { - qDeleteAll(m_functions); - } - uint m_hasVirtuals : 1; uint m_isPolymorphic : 1; uint m_hasNonpublic : 1; @@ -97,13 +92,13 @@ public: AbstractMetaClass *m_extendedNamespace = nullptr; const AbstractMetaClass *m_templateBaseClass = nullptr; - AbstractMetaFunctionList m_functions; + AbstractMetaFunctionCList m_functions; AbstractMetaFieldList m_fields; AbstractMetaEnumList m_enums; QList<QPropertySpec> m_propertySpecs; AbstractMetaClassList m_innerClasses; - AbstractMetaFunctionList m_externalConversionOperators; + AbstractMetaFunctionCList m_externalConversionOperators; QStringList m_baseClassNames; // Base class names from C++, including rejected TypeEntries m_templateArgs; @@ -146,10 +141,10 @@ bool AbstractMetaClass::isPolymorphic() const /******************************************************************************* * Returns a list of all the functions with a given name */ -AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const +AbstractMetaFunctionCList AbstractMetaClass::queryFunctionsByName(const QString &name) const { - AbstractMetaFunctionList returned; - for (AbstractMetaFunction *function : d->m_functions) { + AbstractMetaFunctionCList returned; + for (const auto &function : d->m_functions) { if (function->name() == name) returned.append(function); } @@ -161,7 +156,7 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString & * Returns a list of all the functions retrieved during parsing which should * be added to the API. */ -AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const +AbstractMetaFunctionCList AbstractMetaClass::functionsInTargetLang() const { FunctionQueryOptions default_flags = NormalFunctions | Visible | NotRemovedFromTargetLang; @@ -172,7 +167,7 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const public_flags |= WasPublic; // Constructors - AbstractMetaFunctionList returned = queryFunctions(Constructors | default_flags | public_flags); + AbstractMetaFunctionCList returned = queryFunctions(Constructors | default_flags | public_flags); // Final functions returned += queryFunctions(FinalInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags); @@ -189,18 +184,18 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const return returned; } -AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const +AbstractMetaFunctionCList AbstractMetaClass::implicitConversions() const { if (!hasCloneOperator() && !hasExternalConversionOperators()) - return AbstractMetaFunctionList(); + return {}; - AbstractMetaFunctionList returned; - const AbstractMetaFunctionList list = queryFunctions(Constructors) + externalConversionOperators(); + AbstractMetaFunctionCList returned; + const auto list = queryFunctions(Constructors) + externalConversionOperators(); // Exclude anything that uses rvalue references, be it a move // constructor "QPolygon(QPolygon &&)" or something else like // "QPolygon(QVector<QPoint> &&)". - for (AbstractMetaFunction *f : list) { + for (const auto &f : list) { if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1 || f->isConversionOperator()) && !f->isExplicit() && f->functionType() != AbstractMetaFunction::CopyConstructorFunction @@ -213,11 +208,11 @@ AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const return returned; } -AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptions query) const +AbstractMetaFunctionCList AbstractMetaClass::operatorOverloads(OperatorQueryOptions query) const { - const AbstractMetaFunctionList &list = queryFunctions(OperatorOverloads | Visible); - AbstractMetaFunctionList returned; - for (AbstractMetaFunction *f : list) { + const auto &list = queryFunctions(OperatorOverloads | Visible); + AbstractMetaFunctionCList returned; + for (const auto &f : list) { if (((query & ArithmeticOp) && f->isArithmeticOperator()) || ((query & BitwiseOp) && f->isBitwiseOperator()) || ((query & ComparisonOp) && f->isComparisonOperator()) @@ -234,7 +229,7 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio bool AbstractMetaClass::hasArithmeticOperatorOverload() const { - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto & f: d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate()) return true; } @@ -243,7 +238,7 @@ bool AbstractMetaClass::hasArithmeticOperatorOverload() const bool AbstractMetaClass::hasBitwiseOperatorOverload() const { - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto & f: d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate()) return true; } @@ -252,7 +247,7 @@ bool AbstractMetaClass::hasBitwiseOperatorOverload() const bool AbstractMetaClass::hasComparisonOperatorOverload() const { - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto &f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate()) return true; } @@ -261,7 +256,7 @@ bool AbstractMetaClass::hasComparisonOperatorOverload() const bool AbstractMetaClass::hasLogicalOperatorOverload() const { - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto &f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate()) return true; } @@ -303,20 +298,20 @@ void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls) d->m_templateBaseClass = cls; } -const AbstractMetaFunctionList &AbstractMetaClass::functions() const +const AbstractMetaFunctionCList &AbstractMetaClass::functions() const { return d->m_functions; } -void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions) +void AbstractMetaClass::setFunctions(const AbstractMetaFunctionCList &functions) { d->m_functions = functions; // Functions must be sorted by name before next loop sortFunctions(); - for (AbstractMetaFunction *f : qAsConst(d->m_functions)) { - f->setOwnerClass(this); + for (const auto &f : qAsConst(d->m_functions)) { + qSharedPointerConstCast<AbstractMetaFunction>(f)->setOwnerClass(this); if (!f->isPublic()) d->m_hasNonpublic = true; } @@ -324,8 +319,8 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions) bool AbstractMetaClass::hasDefaultToStringFunction() const { - const AbstractMetaFunctionList &funcs = queryFunctionsByName(QLatin1String("toString")); - for (const AbstractMetaFunction *f : funcs) { + const auto &funcs = queryFunctionsByName(QLatin1String("toString")); + for (const auto &f : funcs) { if (!f->actualMinimumArgumentCount()) return true; } @@ -362,10 +357,10 @@ void AbstractMetaClass::addPropertySpec(const QPropertySpec &spec) d->m_propertySpecs << spec; } -void AbstractMetaClass::addFunction(AbstractMetaFunction *function) +void AbstractMetaClass::addFunction(const AbstractMetaFunctionCPtr &function) { Q_ASSERT(!function->signature().startsWith(QLatin1Char('('))); - function->setOwnerClass(this); + qSharedPointerConstCast<AbstractMetaFunction>(function)->setOwnerClass(this); if (!function->isDestructor()) d->m_functions << function; @@ -382,7 +377,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const if (!other->isSignal()) return false; - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto &f : d->m_functions) { if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName) return other->modifiedName() == f->modifiedName(); } @@ -535,17 +530,17 @@ QString AbstractMetaClass::qualifiedCppName() const bool AbstractMetaClass::hasFunction(const QString &str) const { - return findFunction(str); + return !findFunction(str).isNull(); } -const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const +AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(const QString &functionName) const { return AbstractMetaFunction::find(d->m_functions, functionName); } bool AbstractMetaClass::hasProtectedFunctions() const { - for (AbstractMetaFunction *func : d->m_functions) { + for (const auto &func : d->m_functions) { if (func->isProtected()) return true; } @@ -637,12 +632,12 @@ std::optional<QPropertySpec> return {}; } -AbstractMetaFunctionList AbstractMetaClass::externalConversionOperators() const +const AbstractMetaFunctionCList &AbstractMetaClass::externalConversionOperators() const { return d->m_externalConversionOperators; } -void AbstractMetaClass::addExternalConversionOperator(AbstractMetaFunction *conversionOp) +void AbstractMetaClass::addExternalConversionOperator(const AbstractMetaFunctionCPtr &conversionOp) { if (!d->m_externalConversionOperators.contains(conversionOp)) d->m_externalConversionOperators.append(conversionOp); @@ -712,27 +707,18 @@ bool AbstractMetaClass::deleteInMainThread() const || (!d->m_baseClasses.isEmpty() && d->m_baseClasses.constFirst()->deleteInMainThread()); } -static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func) -{ - for (const AbstractMetaFunction *f : l) { - if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar) - return true; - } - return false; -} - bool AbstractMetaClass::hasConstructors() const { return AbstractMetaClass::queryFirstFunction(d->m_functions, Constructors) != nullptr; } -const AbstractMetaFunction *AbstractMetaClass::copyConstructor() const +AbstractMetaFunctionCPtr AbstractMetaClass::copyConstructor() const { - for (const AbstractMetaFunction *f : d->m_functions) { + for (const auto &f : d->m_functions) { if (f->functionType() == AbstractMetaFunction::CopyConstructorFunction) return f; } - return nullptr; + return {}; } bool AbstractMetaClass::hasCopyConstructor() const @@ -742,8 +728,8 @@ bool AbstractMetaClass::hasCopyConstructor() const bool AbstractMetaClass::hasPrivateCopyConstructor() const { - const AbstractMetaFunction *copyCt = copyConstructor(); - return copyCt && copyCt->isPrivate(); + const auto copyCt = copyConstructor(); + return !copyCt.isNull() && copyCt->isPrivate(); } void AbstractMetaClass::addDefaultConstructor() @@ -761,7 +747,7 @@ void AbstractMetaClass::addDefaultConstructor() f->setImplementingClass(this); f->setOriginalAttributes(f->attributes()); - addFunction(f); + addFunction(AbstractMetaFunctionCPtr(f)); this->setHasNonPrivateConstructor(true); } @@ -794,7 +780,7 @@ void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate) f->setImplementingClass(this); f->setOriginalAttributes(f->attributes()); - addFunction(f); + addFunction(AbstractMetaFunctionCPtr(f)); } bool AbstractMetaClass::hasNonPrivateConstructor() const @@ -854,11 +840,6 @@ bool AbstractMetaClass::isConstructible() const return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor(); } -bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const -{ - return functions_contains(d->m_functions, f); -} - bool AbstractMetaClass::generateExceptionHandling() const { return queryFirstFunction(d->m_functions, AbstractMetaClass::Visible @@ -949,29 +930,29 @@ bool AbstractMetaClass::queryFunction(const AbstractMetaFunction *f, FunctionQue return true; } -AbstractMetaFunctionList AbstractMetaClass::queryFunctionList(const AbstractMetaFunctionList &list, +AbstractMetaFunctionCList AbstractMetaClass::queryFunctionList(const AbstractMetaFunctionCList &list, FunctionQueryOptions query) { - AbstractMetaFunctionList result; - for (AbstractMetaFunction *f : list) { - if (queryFunction(f, query)) + AbstractMetaFunctionCList result; + for (const auto &f : list) { + if (queryFunction(f.data(), query)) result.append(f); } return result; } -const AbstractMetaFunction *AbstractMetaClass::queryFirstFunction(const AbstractMetaFunctionList &list, +AbstractMetaFunctionCPtr AbstractMetaClass::queryFirstFunction(const AbstractMetaFunctionCList &list, FunctionQueryOptions query) { - AbstractMetaFunctionList result; - for (AbstractMetaFunction *f : list) { - if (queryFunction(f, query)) + AbstractMetaFunctionCList result; + for (const auto &f : list) { + if (queryFunction(f.data(), query)) return f; } - return nullptr; + return {}; } -AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const +AbstractMetaFunctionCList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const { return AbstractMetaClass::queryFunctionList(d->m_functions, query); } @@ -981,7 +962,7 @@ bool AbstractMetaClass::hasSignals() const return queryFirstFunction(d->m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr; } -AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const +AbstractMetaFunctionCList AbstractMetaClass::cppSignalFunctions() const { return queryFunctions(Signals | Visible | NotRemovedFromTargetLang); } @@ -1056,7 +1037,7 @@ void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMet } } -void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const +void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const { if (isNamespace()) { invisibleNamespaceRecursion([funcList](AbstractMetaClass *c) { @@ -1088,7 +1069,8 @@ static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractM } } -static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const AbstractMetaFunction *meta_function) +static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, + const AbstractMetaFunctionCPtr &meta_function) { Q_ASSERT(metaClass); Q_ASSERT(meta_function); @@ -1106,13 +1088,13 @@ void AbstractMetaClass::fixFunctions() d->m_functionsFixed = true; - AbstractMetaFunctionList funcs = functions(); - AbstractMetaFunctionList nonRemovedFuncs; + AbstractMetaFunctionCList funcs = functions(); + AbstractMetaFunctionCList nonRemovedFuncs; nonRemovedFuncs.reserve(funcs.size()); for (auto f : qAsConst(funcs)) { // Fishy: Setting up of implementing/declaring/base classes changes // the applicable modifications; clear cached ones. - f->clearModificationsCache(); + qSharedPointerConstCast<AbstractMetaFunction>(f)->clearModificationsCache(); if (!f->isRemovedFromAllLanguages(f->implementingClass())) nonRemovedFuncs.append(f); } @@ -1122,7 +1104,7 @@ void AbstractMetaClass::fixFunctions() // Since we always traverse the complete hierarchy we are only // interrested in what each super class implements, not what // we may have propagated from their base classes again. - AbstractMetaFunctionList superFuncs; + AbstractMetaFunctionCList superFuncs; // Super classes can never be final if (superClass->isFinalInTargetLang()) { qCWarning(lcShiboken).noquote().nospace() @@ -1130,11 +1112,11 @@ void AbstractMetaClass::fixFunctions() *superClass -= AbstractMetaAttributes::FinalInTargetLang; } superFuncs = superClass->queryFunctions(AbstractMetaClass::ClassImplements); - AbstractMetaFunctionList virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions); + const auto virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions); superFuncs += virtuals; - QSet<AbstractMetaFunction *> funcsToAdd; - for (auto sf : qAsConst(superFuncs)) { + QSet<AbstractMetaFunctionCPtr> funcsToAdd; + for (const auto &sf : qAsConst(superFuncs)) { if (sf->isRemovedFromAllLanguages(sf->implementingClass())) continue; @@ -1145,8 +1127,9 @@ void AbstractMetaClass::fixFunctions() // we generally don't care about private functions, but we have to get the ones that are // virtual in case they override abstract functions. bool add = (sf->isNormal() || sf->isSignal() || sf->isEmptyFunction()); - for (AbstractMetaFunction *f : qAsConst(nonRemovedFuncs)) { - const AbstractMetaFunction::CompareResult cmp = f->compareTo(sf); + for (const auto &cf : qAsConst(nonRemovedFuncs)) { + AbstractMetaFunctionPtr f(qSharedPointerConstCast<AbstractMetaFunction>(cf)); + const AbstractMetaFunction::CompareResult cmp = cf->compareTo(sf.data()); if (cmp & AbstractMetaFunction::EqualModifiedName) { add = false; @@ -1172,7 +1155,7 @@ void AbstractMetaClass::fixFunctions() if (f->visibility() != sf->visibility()) { qCWarning(lcShiboken, "%s", - qPrintable(msgFunctionVisibilityModified(this, f))); + qPrintable(msgFunctionVisibilityModified(this, f.data()))); #if 0 // If new visibility is private, we can't // do anything. If it isn't, then we @@ -1216,7 +1199,7 @@ void AbstractMetaClass::fixFunctions() if (!hasNonFinalModifier && !isBaseImplPrivate) { qCWarning(lcShiboken, "%s", - qPrintable(msgShadowingFunction(sf, f))); + qPrintable(msgShadowingFunction(sf.data(), f.data()))); } } } @@ -1248,19 +1231,19 @@ void AbstractMetaClass::fixFunctions() funcsToAdd << sf; } - for (AbstractMetaFunction *f : qAsConst(funcsToAdd)) { + for (const auto &f : qAsConst(funcsToAdd)) { AbstractMetaFunction *copy = f->copy(); (*copy) += AddedMethod; - funcs.append(copy); + funcs.append(AbstractMetaFunctionCPtr(copy)); } } bool hasPrivateConstructors = false; bool hasPublicConstructors = false; - for (AbstractMetaFunction *func : qAsConst(funcs)) { + for (const auto &func : qAsConst(funcs)) { for (const auto &mod : func->modifications(this)) { if (mod.isRenameModifier()) - func->setName(mod.renamedToName()); + qSharedPointerConstCast<AbstractMetaFunction>(func)->setName(mod.renamedToName()); } // Make sure class is abstract if one of the functions is diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h index b72acfe8c..f0c08d673 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h @@ -99,16 +99,15 @@ public: void fixFunctions(); - const AbstractMetaFunctionList &functions() const; - void setFunctions(const AbstractMetaFunctionList &functions); - void addFunction(AbstractMetaFunction *function); - bool hasFunction(const AbstractMetaFunction *f) const; + const AbstractMetaFunctionCList &functions() const; + void setFunctions(const AbstractMetaFunctionCList &functions); + void addFunction(const AbstractMetaFunctionCPtr &function); bool hasFunction(const QString &str) const; - const AbstractMetaFunction* findFunction(const QString& functionName) const; + AbstractMetaFunctionCPtr findFunction(const QString& functionName) const; bool hasSignal(const AbstractMetaFunction *f) const; bool hasConstructors() const; - const AbstractMetaFunction *copyConstructor() const; + AbstractMetaFunctionCPtr copyConstructor() const; bool hasCopyConstructor() const; bool hasPrivateCopyConstructor() const; @@ -134,17 +133,17 @@ public: bool generateExceptionHandling() const; - AbstractMetaFunctionList queryFunctionsByName(const QString &name) const; + AbstractMetaFunctionCList queryFunctionsByName(const QString &name) const; static bool queryFunction(const AbstractMetaFunction *f, FunctionQueryOptions query); - static AbstractMetaFunctionList queryFunctionList(const AbstractMetaFunctionList &list, + static AbstractMetaFunctionCList queryFunctionList(const AbstractMetaFunctionCList &list, FunctionQueryOptions query); - static const AbstractMetaFunction *queryFirstFunction(const AbstractMetaFunctionList &list, - FunctionQueryOptions query); + static AbstractMetaFunctionCPtr queryFirstFunction(const AbstractMetaFunctionCList &list, + FunctionQueryOptions query); - AbstractMetaFunctionList queryFunctions(FunctionQueryOptions query) const; - AbstractMetaFunctionList functionsInTargetLang() const; - AbstractMetaFunctionList cppSignalFunctions() const; - AbstractMetaFunctionList implicitConversions() const; + AbstractMetaFunctionCList queryFunctions(FunctionQueryOptions query) const; + AbstractMetaFunctionCList functionsInTargetLang() const; + AbstractMetaFunctionCList cppSignalFunctions() const; + AbstractMetaFunctionCList implicitConversions() const; /** * Retrieves all class' operator overloads that meet @@ -154,7 +153,7 @@ public: * /return list of operator overload methods that meet the * query criteria */ - AbstractMetaFunctionList operatorOverloads(OperatorQueryOptions query = AllOperators) const; + AbstractMetaFunctionCList operatorOverloads(OperatorQueryOptions query = AllOperators) const; bool hasArithmeticOperatorOverload() const; bool hasBitwiseOperatorOverload() const; @@ -178,7 +177,7 @@ public: void getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const; void getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const; - void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const; + void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionCList *funcList) const; QString fullName() const; @@ -300,9 +299,9 @@ public: /// Returns a list of conversion operators for this class. The conversion /// operators are defined in other classes of the same module. - AbstractMetaFunctionList externalConversionOperators() const; + const AbstractMetaFunctionCList &externalConversionOperators() const; /// Adds a converter operator for this class. - void addExternalConversionOperator(AbstractMetaFunction* conversionOp); + void addExternalConversionOperator(const AbstractMetaFunctionCPtr &conversionOp); /// Returns true if this class has any converter operators defined elsewhere. bool hasExternalConversionOperators() const; diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h index 91a029c06..66e6e467f 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h @@ -40,14 +40,17 @@ class AbstractMetaEnumValue; class AbstractMetaFunction; class AbstractMetaType; +using AbstractMetaFunctionPtr = QSharedPointer<AbstractMetaFunction>; +using AbstractMetaFunctionCPtr = QSharedPointer<const AbstractMetaFunction>; + using AbstractMetaArgumentList = QList<AbstractMetaArgument>; using AbstractMetaClassList = QList<AbstractMetaClass *>; using AbstractMetaClassCList = QList<const AbstractMetaClass *>; using AbstractMetaEnumList = QList<AbstractMetaEnum>; using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>; using AbstractMetaFieldList = QList<AbstractMetaField>; -using AbstractMetaFunctionList = QList<AbstractMetaFunction *>; -using AbstractMetaFunctionCList = QList<const AbstractMetaFunction *>; +using AbstractMetaFunctionRawPtrList = QList<AbstractMetaFunction *>; +using AbstractMetaFunctionCList = QList<AbstractMetaFunctionCPtr>; using AbstractMetaTypeList = QList<AbstractMetaType>; #endif // ABSTRACTMETALANG_TYPEDEFS_H diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp index dba0d23da..5e9d18729 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.cpp +++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp @@ -128,7 +128,7 @@ const AbstractMetaEnumList &ApiExtractor::globalEnums() const return m_builder->globalEnums(); } -const AbstractMetaFunctionList &ApiExtractor::globalFunctions() const +const AbstractMetaFunctionCList &ApiExtractor::globalFunctions() const { Q_ASSERT(m_builder); return m_builder->globalFunctions(); diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h index f9a33ae60..856734593 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.h +++ b/sources/shiboken6/ApiExtractor/apiextractor.h @@ -83,7 +83,7 @@ public: void setLanguageLevel(LanguageLevel languageLevel); const AbstractMetaEnumList &globalEnums() const; - const AbstractMetaFunctionList &globalFunctions() const; + const AbstractMetaFunctionCList &globalFunctions() const; const AbstractMetaClassList &classes() const; const AbstractMetaClassList &smartPointers() const; AbstractMetaClassList classesTopologicalSorted(const Dependencies &additionalDependencies = Dependencies()) const; diff --git a/sources/shiboken6/ApiExtractor/docparser.cpp b/sources/shiboken6/ApiExtractor/docparser.cpp index 52afbfb84..d2f8a5234 100644 --- a/sources/shiboken6/ApiExtractor/docparser.cpp +++ b/sources/shiboken6/ApiExtractor/docparser.cpp @@ -73,7 +73,7 @@ QString DocParser::execXQuery(const XQueryPtr &xquery, const QString& query) con return result; } -bool DocParser::skipForQuery(const AbstractMetaFunction *func) +bool DocParser::skipForQuery(const AbstractMetaFunctionCPtr &func) { // Skip private functions and copies created by AbstractMetaClass::fixFunctions() if (!func || func->isPrivate() @@ -94,9 +94,9 @@ bool DocParser::skipForQuery(const AbstractMetaFunction *func) return false; } -AbstractMetaFunctionList DocParser::documentableFunctions(const AbstractMetaClass *metaClass) +AbstractMetaFunctionCList DocParser::documentableFunctions(const AbstractMetaClass *metaClass) { - AbstractMetaFunctionList result = metaClass->functionsInTargetLang(); + auto result = metaClass->functionsInTargetLang(); for (int i = result.size() - 1; i >= 0; --i) { if (DocParser::skipForQuery(result.at(i)) || result.at(i)->isUserAdded()) result.removeAt(i); diff --git a/sources/shiboken6/ApiExtractor/docparser.h b/sources/shiboken6/ApiExtractor/docparser.h index 1dccae4d6..37c914b43 100644 --- a/sources/shiboken6/ApiExtractor/docparser.h +++ b/sources/shiboken6/ApiExtractor/docparser.h @@ -112,14 +112,14 @@ public: */ virtual Documentation retrieveModuleDocumentation(const QString& name) = 0; - static bool skipForQuery(const AbstractMetaFunction *func); + static bool skipForQuery(const AbstractMetaFunctionCPtr &func); protected: QString getDocumentation(const XQueryPtr &xquery, const QString& query, const DocModificationList& mods) const; - static AbstractMetaFunctionList documentableFunctions(const AbstractMetaClass *metaClass); + static AbstractMetaFunctionCList documentableFunctions(const AbstractMetaClass *metaClass); private: QString m_packageName; diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp index 90afc245c..a731479c3 100644 --- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp +++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp @@ -42,7 +42,7 @@ #include <QtCore/QFile> #include <QtCore/QDir> -static QString getSectionKindAttr(const AbstractMetaFunction *func) +static QString getSectionKindAttr(const AbstractMetaFunctionCPtr &func) { if (func->isSignal()) return QLatin1String("signal"); @@ -121,8 +121,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass) metaClass->setDocumentation(classDoc); //Functions Documentation - const AbstractMetaFunctionList &funcs = DocParser::documentableFunctions(metaClass); - for (AbstractMetaFunction *func : funcs) { + const auto &funcs = DocParser::documentableFunctions(metaClass); + for (const auto &func : funcs) { QString query = QLatin1String("/doxygen/compounddef/sectiondef"); // properties if (func->isPropertyReader() || func->isPropertyWriter() @@ -172,13 +172,13 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass) QString doc = getDocumentation(xquery, funcQuery, DocModificationList()); if (doc.isEmpty()) { qCWarning(lcShibokenDoc, "%s", - qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, func, + qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, func.data(), funcQuery))); } else { funcDoc.setValue(doc, tag.first); } } - func->setDocumentation(funcDoc); + qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(funcDoc); isProperty = false; } diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp index e3ea87f76..5bdd58ae2 100644 --- a/sources/shiboken6/ApiExtractor/messages.cpp +++ b/sources/shiboken6/ApiExtractor/messages.cpp @@ -52,7 +52,7 @@ QString msgNoFunctionForModification(const AbstractMetaClass *klass, const QString &signature, const QString &originalSignature, const QStringList &possibleSignatures, - const AbstractMetaFunctionList &allFunctions) + const AbstractMetaFunctionCList &allFunctions) { QString result; QTextStream str(&result); diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h index d26200abf..21b16a264 100644 --- a/sources/shiboken6/ApiExtractor/messages.h +++ b/sources/shiboken6/ApiExtractor/messages.h @@ -64,7 +64,7 @@ QString msgNoFunctionForModification(const AbstractMetaClass *klass, const QString &signature, const QString &originalSignature, const QStringList &possibleSignatures, - const AbstractMetaFunctionList &allFunctions); + const AbstractMetaFunctionCList &allFunctions); QString msgClassOfEnumNotFound(const EnumTypeEntry *entry); diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp index 815532a38..3b5837c95 100644 --- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp +++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp @@ -106,7 +106,7 @@ enum FunctionMatchFlags }; static QString functionXQuery(const QString &classQuery, - const AbstractMetaFunction *func, + const AbstractMetaFunctionCPtr &func, unsigned matchFlags = MatchArgumentCount | MatchArgumentType | DescriptionOnly) { @@ -165,7 +165,7 @@ static QString msgArgumentCountMatch(const AbstractMetaFunction *func, QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName, const AbstractMetaClass* metaClass, const QString &classQuery, - const AbstractMetaFunction *func, + const AbstractMetaFunctionCPtr &func, const DocModificationList &signedModifs, const XQueryPtr &xquery, QString *errorMessage) @@ -182,8 +182,11 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName, const QString propertyQuery = classQuery + QLatin1String("/property[@name=\"") + prop.name() + QLatin1String("\"]/description"); const QString properyDocumentation = getDocumentation(xquery, propertyQuery, funcModifs); - if (properyDocumentation.isEmpty()) - *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func, propertyQuery); + if (properyDocumentation.isEmpty()) { + *errorMessage = + msgCannotFindDocumentation(sourceFileName, metaClass, func.data(), + propertyQuery); + } return properyDocumentation; } @@ -192,7 +195,7 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName, const QString result = getDocumentation(xquery, fullQuery, funcModifs); if (!result.isEmpty()) return result; - *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func, fullQuery); + *errorMessage = msgCannotFindDocumentation(sourceFileName, metaClass, func.data(), fullQuery); if (func->arguments().isEmpty()) // No arguments, can't be helped return result; // Test whether some mismatch in argument types occurred by checking for @@ -208,7 +211,7 @@ QString QtDocParser::queryFunctionDocumentation(const QString &sourceFileName, + QLatin1String("\" obtained by matching the argument count only.")); return getDocumentation(xquery, countOnlyQuery, funcModifs); } - *errorMessage += msgArgumentCountMatch(func, signatures); + *errorMessage += msgArgumentCountMatch(func.data(), signatures); return result; } @@ -269,14 +272,14 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass) metaClass->setDocumentation(doc); //Functions Documentation - const AbstractMetaFunctionList &funcs = DocParser::documentableFunctions(metaClass); - for (AbstractMetaFunction *func : funcs) { + const auto &funcs = DocParser::documentableFunctions(metaClass); + for (const auto &func : funcs) { const QString documentation = queryFunctionDocumentation(sourceFileName, metaClass, classQuery, func, signedModifs, xquery, &errorMessage); if (!errorMessage.isEmpty()) qCWarning(lcShibokenDoc, "%s", qPrintable(errorMessage)); - func->setDocumentation(Documentation(documentation)); + qSharedPointerConstCast<AbstractMetaFunction>(func)->setDocumentation(Documentation(documentation)); } #if 0 // Fields diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.h b/sources/shiboken6/ApiExtractor/qtdocparser.h index b01139de6..ee6542ca3 100644 --- a/sources/shiboken6/ApiExtractor/qtdocparser.h +++ b/sources/shiboken6/ApiExtractor/qtdocparser.h @@ -43,7 +43,7 @@ private: QString queryFunctionDocumentation(const QString &sourceFileName, const AbstractMetaClass* metaClass, const QString &classQuery, - const AbstractMetaFunction *func, + const AbstractMetaFunctionCPtr &func, const DocModificationList &signedModifs, const XQueryPtr &xquery, QString *errorMessage); diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp index 8e715866e..1fd77a01c 100644 --- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp @@ -70,7 +70,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace() QVERIFY(classes[0]->hasConstructors()); QCOMPARE(classes[0]->functions().size(), 2); // default ctor + copy ctor - AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors); + auto ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); if (ctors.constFirst()->minimalSignature() != QLatin1String("ClassName()")) qSwap(ctors[0], ctors[1]); @@ -88,11 +88,11 @@ void TestAbstractMetaClass::testClassNameUnderNamespace() // QVERIFY(classes[0]->hasNonPrivateConstructor()); } -static AbstractMetaFunctionList virtualFunctions(const AbstractMetaClass *c) +static AbstractMetaFunctionCList virtualFunctions(const AbstractMetaClass *c) { - AbstractMetaFunctionList result; - const AbstractMetaFunctionList &functions = c->functions(); - for (AbstractMetaFunction *f : functions) { + AbstractMetaFunctionCList result; + const auto &functions = c->functions(); + for (const auto &f : functions) { if (f->isVirtual()) result.append(f); } @@ -150,9 +150,9 @@ public: QVERIFY(f->attributes() & AbstractMetaAttributes::FinalCppClass); // implementing class, ownclass, declaringclass - AbstractMetaFunction *ctorA = a->queryFunctions(AbstractMetaClass::Constructors).constFirst(); - AbstractMetaFunction *ctorB = b->queryFunctions(AbstractMetaClass::Constructors).constFirst(); - AbstractMetaFunction *ctorC = c->queryFunctions(AbstractMetaClass::Constructors).constFirst(); + const auto ctorA = a->queryFunctions(AbstractMetaClass::Constructors).constFirst(); + const auto ctorB = b->queryFunctions(AbstractMetaClass::Constructors).constFirst(); + const auto ctorC = c->queryFunctions(AbstractMetaClass::Constructors).constFirst(); QVERIFY(ctorA->isConstructor()); QVERIFY(!ctorA->isVirtual()); QVERIFY(ctorB->isConstructor()); @@ -163,19 +163,19 @@ public: QCOMPARE(ctorA->ownerClass(), a); QCOMPARE(ctorA->declaringClass(), a); - const AbstractMetaFunctionList virtualFunctionsA = virtualFunctions(a); - const AbstractMetaFunctionList virtualFunctionsB = virtualFunctions(b); - const AbstractMetaFunctionList virtualFunctionsC = virtualFunctions(c); - const AbstractMetaFunctionList virtualFunctionsF = virtualFunctions(f); + const auto virtualFunctionsA = virtualFunctions(a); + const auto virtualFunctionsB = virtualFunctions(b); + const auto virtualFunctionsC = virtualFunctions(c); + const auto virtualFunctionsF = virtualFunctions(f); QCOMPARE(virtualFunctionsA.size(), 1); // Add a pureVirtualMethods method !? QCOMPARE(virtualFunctionsB.size(), 1); QCOMPARE(virtualFunctionsC.size(), 1); QCOMPARE(virtualFunctionsF.size(), 1); - const AbstractMetaFunction* funcA = virtualFunctionsA.constFirst(); - const AbstractMetaFunction* funcB = virtualFunctionsB.constFirst(); - const AbstractMetaFunction* funcC = virtualFunctionsC.constFirst(); - const AbstractMetaFunction* funcF = virtualFunctionsF.constFirst(); + const auto funcA = virtualFunctionsA.constFirst(); + const auto funcB = virtualFunctionsB.constFirst(); + const auto funcC = virtualFunctionsC.constFirst(); + const auto funcF = virtualFunctionsF.constFirst(); QCOMPARE(funcA->ownerClass(), a); QVERIFY(funcC->attributes() & AbstractMetaAttributes::VirtualCppMethod); @@ -242,7 +242,7 @@ void TestAbstractMetaClass::testDefaultValues() QCOMPARE(classes.count(), 2); AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1); - AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).constFirst(); + const auto method = classA->queryFunctionsByName(QLatin1String("method")).constFirst(); const AbstractMetaArgument &arg = method->arguments().constFirst(); QCOMPARE(arg.defaultValueExpression(), arg.originalDefaultValueExpression()); } @@ -270,8 +270,9 @@ void TestAbstractMetaClass::testModifiedDefaultValues() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.count(), 2); AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); - QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1); - AbstractMetaFunction *method = classA->queryFunctionsByName(QLatin1String("method")).constFirst(); + const auto methodMatches = classA->queryFunctionsByName(QLatin1String("method")); + QCOMPARE(methodMatches.count(), 1); + const auto method = methodMatches.constFirst(); const AbstractMetaArgument &arg = method->arguments().constFirst(); QCOMPARE(arg.defaultValueExpression(), QLatin1String("Hello")); QCOMPARE(arg.originalDefaultValueExpression(), QLatin1String("A::B()")); @@ -326,8 +327,8 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass() QVERIFY(classA); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("A::B")); QVERIFY(classB); - const AbstractMetaFunction *fooF = classB->findFunction(QLatin1String("foo")); - QVERIFY(fooF); + const auto fooF = classB->findFunction(QLatin1String("foo")); + QVERIFY(!fooF.isNull()); } void TestAbstractMetaClass::testSpecialFunctions() @@ -356,11 +357,11 @@ void TestAbstractMetaClass::testSpecialFunctions() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); + auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction); QCOMPARE(ctors.at(1)->functionType(), AbstractMetaFunction::CopyConstructorFunction); - AbstractMetaFunctionList assigmentOps = classA->queryFunctionsByName(QLatin1String("operator=")); + auto assigmentOps = classA->queryFunctionsByName(QLatin1String("operator=")); QCOMPARE(assigmentOps.size(), 1); QCOMPARE(assigmentOps.constFirst()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction); @@ -424,7 +425,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors() QVERIFY(classA); QCOMPARE(classA->functions().size(), 2); - AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); + auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); if (ctors.constFirst()->minimalSignature() != QLatin1String("A()")) qSwap(ctors[0], ctors[1]); @@ -491,7 +492,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors() AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); + auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); if (ctors.constFirst()->minimalSignature() != QLatin1String("A()")) qSwap(ctors[0], ctors[1]); @@ -529,7 +530,7 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors() AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); + const auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 1); QCOMPARE(ctors.constFirst()->arguments().size(), 0); QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()")); @@ -550,7 +551,7 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors() AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); + const auto ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 1); QCOMPARE(ctors.constFirst()->arguments().size(), 0); QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()")); diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp index e65b0f214..897940cd5 100644 --- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp @@ -74,7 +74,7 @@ void TestAbstractMetaType::testConstCharPtrType() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 1); - AbstractMetaFunction *func = builder->globalFunctions().constFirst(); + const auto func = builder->globalFunctions().constFirst(); AbstractMetaType rtype = func->type(); // Test properties of const char* QVERIFY(!rtype.isVoid()); @@ -111,8 +111,7 @@ void TestAbstractMetaType::testApiVersionSupported() QCOMPARE(classes.size(), 2); - AbstractMetaFunctionList functions = builder->globalFunctions(); - QCOMPARE(functions.size(), 2); + QCOMPARE(builder->globalFunctions().size(), 2); } @@ -145,9 +144,9 @@ void TestAbstractMetaType::testCharType() QCOMPARE(classes.size(), 1); QCOMPARE(classes.constFirst()->package(), QLatin1String("Foo")); - AbstractMetaFunctionList functions = builder->globalFunctions(); + const auto functions = builder->globalFunctions(); QCOMPARE(functions.size(), 1); - AbstractMetaFunction *func = functions.constFirst(); + const auto func = functions.constFirst(); AbstractMetaType rtype = func->type(); // Test properties of const char* QVERIFY(!rtype.isVoid()); @@ -205,9 +204,9 @@ void TestAbstractMetaType::testTypedefWithTemplates() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - AbstractMetaFunctionList functions = builder->globalFunctions(); + const auto functions = builder->globalFunctions(); QCOMPARE(functions.count(), 1); - AbstractMetaFunction *function = functions.constFirst(); + const auto function = functions.constFirst(); AbstractMetaArgumentList args = function->arguments(); QCOMPARE(args.count(), 1); const AbstractMetaArgument &arg = args.constFirst(); @@ -232,9 +231,9 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue() QCOMPARE(classes.size(), 1); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunctionList overloads = classA->queryFunctionsByName(QLatin1String("method")); + const auto overloads = classA->queryFunctionsByName(QLatin1String("method")); QCOMPARE(overloads.count(), 1); - AbstractMetaFunction* method = overloads.constFirst(); + const auto method = overloads.constFirst(); QVERIFY(method); AbstractMetaArgumentList args = method->arguments(); QCOMPARE(args.count(), 1); diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp index 83720b8cb..7a52b9b33 100644 --- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp @@ -166,7 +166,7 @@ void TestAddFunction::testAddFunctionConstructor() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->functions().count(), 3); // default and added ctors - AbstractMetaFunction *addedFunc = classA->functions().constLast(); + const auto addedFunc = classA->functions().constLast(); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction); QCOMPARE(addedFunc->arguments().size(), 1); @@ -189,7 +189,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function - AbstractMetaFunction *addedFunc = classA->functions().constLast(); + const auto addedFunc = classA->functions().constLast(); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction); QVERIFY(addedFunc->isUserAdded()); @@ -213,7 +213,7 @@ void TestAddFunction::testAddFunctionCodeSnippets() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunction *addedFunc = classA->functions().constLast(); + const auto addedFunc = classA->functions().constLast(); QVERIFY(addedFunc->hasInjectedCode()); } @@ -243,8 +243,8 @@ void TestAddFunction::testAddFunctionWithoutParenteses() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func")); - QVERIFY(addedFunc); + const auto addedFunc = classA->findFunction(QLatin1String("func")); + QVERIFY(!addedFunc.isNull()); QVERIFY(addedFunc->hasInjectedCode()); QCOMPARE(addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode).count(), 1); } @@ -278,8 +278,8 @@ void TestAddFunction::testAddFunctionWithDefaultArgs() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func")); - QVERIFY(addedFunc); + const auto addedFunc = classA->findFunction(QLatin1String("func")); + QVERIFY(!addedFunc.isNull()); const AbstractMetaArgument &arg = addedFunc->arguments().at(1); QCOMPARE(arg.defaultValueExpression(), QLatin1String("2")); } @@ -342,8 +342,8 @@ void TestAddFunction::testAddFunctionWithVarargs() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func")); - QVERIFY(addedFunc); + const auto addedFunc = classA->findFunction(QLatin1String("func")); + QVERIFY(!addedFunc.isNull()); const AbstractMetaArgument &arg = addedFunc->arguments().constLast(); QVERIFY(arg.type().isVarargs()); QVERIFY(arg.type().typeEntry()->isVarargs()); @@ -366,8 +366,8 @@ void TestAddFunction::testAddStaticFunction() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func")); - QVERIFY(addedFunc); + const auto addedFunc = classA->findFunction(QLatin1String("func")); + QVERIFY(!addedFunc.isNull()); QVERIFY(addedFunc->isStatic()); } @@ -388,7 +388,7 @@ void TestAddFunction::testAddGlobalFunction() </typesystem>\n"; QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); - AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); + const auto globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 2); const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), QLatin1String("B")); QVERIFY(classB); @@ -414,7 +414,7 @@ void TestAddFunction::testAddFunctionWithApiVersion() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true, QLatin1String("0.1"))); QVERIFY(!builder.isNull()); - AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); + const auto globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); } @@ -439,7 +439,8 @@ void TestAddFunction::testModifyAddedFunction() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("Foo")); - const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method")); + const auto method = foo->findFunction(QLatin1String("method")); + QVERIFY(!method.isNull()); QCOMPARE(method->arguments().size(), 2); const AbstractMetaArgument &arg = method->arguments().at(1); QCOMPARE(arg.defaultValueExpression(), QLatin1String("0")); @@ -469,12 +470,12 @@ void TestAddFunction::testAddFunctionOnTypedef() AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("FooInt")); QVERIFY(foo); QVERIFY(foo->hasNonPrivateConstructor()); - const AbstractMetaFunctionList &lst = foo->queryFunctions(AbstractMetaClass::Constructors); - for (const AbstractMetaFunction *f : lst) + const auto &lst = foo->queryFunctions(AbstractMetaClass::Constructors); + for (const auto &f : lst) QVERIFY(f->signature().startsWith(f->name())); QCOMPARE(lst.size(), 2); - const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method")); - QVERIFY(method); + const auto method = foo->findFunction(QLatin1String("method")); + QVERIFY(!method.isNull()); } void TestAddFunction::testAddFunctionWithTemplateArg() @@ -490,7 +491,7 @@ void TestAddFunction::testAddFunctionWithTemplateArg() QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 1); - AbstractMetaFunction *func = builder->globalFunctions().constFirst(); + const auto func = builder->globalFunctions().constFirst(); const AbstractMetaArgument &arg = func->arguments().constFirst(); QCOMPARE(arg.type().instantiations().count(), 1); } diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp index df6280725..22cf7ab40 100644 --- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp @@ -63,8 +63,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger() static QString functionMinimalSignature(const AbstractMetaClass *c, const QString &name) { - const AbstractMetaFunction *f = c->findFunction(name); - return f ? f->minimalSignature() : QString(); + const auto f = c->findFunction(name); + return f.isNull() ? QString() : f->minimalSignature(); } void TestArrayArgument::testArraySignature() diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp index b9345ddbc..32071f533 100644 --- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp @@ -65,14 +65,14 @@ void TestConversionOperator::testConversionOperator() QCOMPARE(classC->functions().count(), 3); QCOMPARE(classA->externalConversionOperators().count(), 2); - AbstractMetaFunction *convOp = nullptr; - for (AbstractMetaFunction *func : classB->functions()) { + AbstractMetaFunctionCPtr convOp; + for (const auto &func : classB->functions()) { if (func->isConversionOperator()) { convOp = func; break; } } - QVERIFY(convOp); + QVERIFY(!convOp.isNull()); QVERIFY(classA->externalConversionOperators().contains(convOp)); } diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp index 710361b47..df744e994 100644 --- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp @@ -64,7 +64,7 @@ void TestEnum::testEnumCppSignature() QCOMPARE(globalEnums.constFirst().name(), QLatin1String("GlobalEnum")); // enum as parameter of a function - AbstractMetaFunctionList functions = builder->globalFunctions(); + const auto functions = builder->globalFunctions(); QCOMPARE(functions.count(), 1); QCOMPARE(functions.constFirst()->arguments().count(), 1); QCOMPARE(functions.constFirst()->arguments().constFirst().type().cppSignature(), @@ -73,10 +73,9 @@ void TestEnum::testEnumCppSignature() // enum as parameter of a method const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->enums().count(), 1); - AbstractMetaFunctionList funcs = classA->queryFunctionsByName(QLatin1String("method")); + const auto funcs = classA->queryFunctionsByName(QLatin1String("method")); QVERIFY(!funcs.isEmpty()); - AbstractMetaFunction *method = funcs.constFirst(); - QVERIFY(method); + const auto method = funcs.constFirst(); AbstractMetaArgument arg = method->arguments().constFirst(); QCOMPARE(arg.type().name(), QLatin1String("ClassEnum")); QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum")); diff --git a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp index ba8f22706..f58ea6f64 100644 --- a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp @@ -82,7 +82,7 @@ void TestFunctionTag::testRenameGlobalFunction() QVERIFY(func); QCOMPARE(builder->globalFunctions().size(), 1); - const AbstractMetaFunction *metaFunc = builder->globalFunctions().constFirst(); + const auto metaFunc = builder->globalFunctions().constFirst(); QVERIFY(metaFunc); QCOMPARE(metaFunc->modifications().size(), 1); diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp index ef9699cad..928122967 100644 --- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp @@ -58,7 +58,7 @@ void TestImplicitConversions::testWithPrivateCtors() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C")); - AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); + const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 1); QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(), classC->typeEntry()); @@ -88,7 +88,7 @@ void TestImplicitConversions::testWithModifiedVisibility() QCOMPARE(classes.count(), 2); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); + const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 1); QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(), classB->typeEntry()); @@ -122,7 +122,7 @@ void TestImplicitConversions::testWithAddedCtor() QCOMPARE(classes.count(), 3); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); - AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); + auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 2); // Added constructors with custom types should never result in implicit converters. @@ -149,17 +149,17 @@ void TestImplicitConversions::testWithExternalConversionOperator() QCOMPARE(classes.count(), 2); AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); + const auto implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 1); - AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators(); + const auto &externalConvOps = classA->externalConversionOperators(); QCOMPARE(externalConvOps.count(), 1); - const AbstractMetaFunction *convOp = nullptr; - for (const AbstractMetaFunction *func : classB->functions()) { + AbstractMetaFunctionCPtr convOp; + for (const auto &func : classB->functions()) { if (func->isConversionOperator()) convOp = func; } - QVERIFY(convOp); + QVERIFY(!convOp.isNull()); QCOMPARE(implicitConvs.constFirst(), convOp); } diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp index 6928448b7..0fa07b75c 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp @@ -67,8 +67,8 @@ void TestModifyFunction::testRenameArgument() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); - const AbstractMetaFunction* func = classA->findFunction(QLatin1String("method")); - Q_ASSERT(func); + const auto func = classA->findFunction(QLatin1String("method")); + QVERIFY(!func.isNull()); QCOMPARE(func->argumentName(1), QLatin1String("otherArg")); } @@ -95,7 +95,8 @@ void TestModifyFunction::testOwnershipTransfer() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method")); + const auto func = classB->findFunction(QLatin1String("method")); + QVERIFY(!func.isNull()); QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership); } @@ -143,7 +144,7 @@ void TestModifyFunction::invalidateAfterUse() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("call")); + auto func = classB->findFunction(QLatin1String("call")); QCOMPARE(func->modifications().size(), 1); QCOMPARE(func->modifications().at(0).argument_mods().size(), 1); QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse); @@ -216,7 +217,7 @@ void TestModifyFunction::testWithApiVersion() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("method")); + auto func = classB->findFunction(QLatin1String("method")); QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership); @@ -256,28 +257,28 @@ struct A { QVERIFY(classA); // Nothing specified, true - const AbstractMetaFunction *f1 = classA->findFunction(QLatin1String("f1")); - QVERIFY(f1); + const auto f1 = classA->findFunction(QLatin1String("f1")); + QVERIFY(!f1.isNull()); QVERIFY(!f1->allowThread()); // 'auto' specified, should be false for nontrivial function - const AbstractMetaFunction *f2 = classA->findFunction(QLatin1String("f2")); - QVERIFY(f2); + const auto f2 = classA->findFunction(QLatin1String("f2")); + QVERIFY(!f2.isNull()); QVERIFY(f2->allowThread()); // 'no' specified, should be false - const AbstractMetaFunction *f3 = classA->findFunction(QLatin1String("f3")); - QVERIFY(f3); + const auto f3 = classA->findFunction(QLatin1String("f3")); + QVERIFY(!f3.isNull()); QVERIFY(!f3->allowThread()); // Nothing specified, should be false for simple getter - const AbstractMetaFunction *getter1 = classA->findFunction(QLatin1String("getter1")); - QVERIFY(getter1); + const auto getter1 = classA->findFunction(QLatin1String("getter1")); + QVERIFY(!getter1.isNull()); QVERIFY(!getter1->allowThread()); // Forced to true simple getter - const AbstractMetaFunction *getter2 = classA->findFunction(QLatin1String("getter2")); - QVERIFY(getter2); + const auto getter2 = classA->findFunction(QLatin1String("getter2")); + QVERIFY(!getter2.isNull()); QVERIFY(getter2->allowThread()); // Forced to true simple getter } @@ -310,8 +311,8 @@ void TestModifyFunction::testGlobalFunctionModification() ArgumentModification argMod = argMods.constFirst(); QCOMPARE(argMod.replacedDefaultExpression, QLatin1String("A()")); - const AbstractMetaFunction *func = builder->globalFunctions().constFirst(); - QVERIFY(func); + QVERIFY(!builder->globalFunctions().isEmpty()); + const auto func = builder->globalFunctions().constFirst(); QCOMPARE(func->arguments().count(), 1); const AbstractMetaArgument &arg = func->arguments().constFirst(); QCOMPARE(arg.type().cppSignature(), QLatin1String("A *")); @@ -452,19 +453,19 @@ void TestModifyFunction::testScopedModifications() const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction *f = classA->findFunction(QStringLiteral("unspecified")); - QVERIFY(f); + auto f = classA->findFunction(QStringLiteral("unspecified")); + QVERIFY(!f.isNull()); QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Unknown); QCOMPARE(f->generateExceptionHandling(), expectedGenerateUnspecified); QCOMPARE(f->allowThread(), expectedAllowThread); f = classA->findFunction(QStringLiteral("nonThrowing")); - QVERIFY(f); + QVERIFY(!f.isNull()); QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::NoExcept); QCOMPARE(f->generateExceptionHandling(), expectedGenerateNonThrowing); f = classA->findFunction(QStringLiteral("throwing")); - QVERIFY(f); + QVERIFY(!f.isNull()); QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Throws); QCOMPARE(f->generateExceptionHandling(), expectedGenerateThrowing); } diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp index 7702d37d9..748adfc39 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp @@ -62,8 +62,7 @@ void TestMultipleInheritance::testVirtualClass() const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D")); bool functionFound = false; - const AbstractMetaFunctionList &functions = classD->functions(); - for (AbstractMetaFunction *f : functions) { + for (const auto &f : classD->functions()) { if (f->name() == QLatin1String("theBug")) { functionFound = true; break; diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp index 7f0addd6b..99aabe780 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp @@ -57,8 +57,8 @@ void NamespaceTest::testNamespaceMembers() QVERIFY(ns); auto metaEnum = ns->findEnum(QLatin1String("Option")); QVERIFY(metaEnum.has_value()); - const AbstractMetaFunction* func = ns->findFunction(QLatin1String("foo")); - QVERIFY(func); + const auto func = ns->findFunction(QLatin1String("foo")); + QVERIFY(!func.isNull()); } void NamespaceTest::testNamespaceInnerClassMembers() @@ -89,8 +89,8 @@ void NamespaceTest::testNamespaceInnerClassMembers() QVERIFY(ins); const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass")); QVERIFY(sc); - const AbstractMetaFunction* meth = sc->findFunction(QLatin1String("method")); - QVERIFY(meth); + const auto meth = sc->findFunction(QLatin1String("method")); + QVERIFY(!meth.isNull()); } QTEST_APPLESS_MAIN(NamespaceTest) diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp index 4613eeaa5..71daef051 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp @@ -73,7 +73,7 @@ void TestNestedTypes::testNestedTypesModifications() CodeSnip snip = ins->typeEntry()->codeSnips().constFirst(); QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code1();")); - AbstractMetaFunction *addedFunc = ins->functions().constFirst(); + const auto addedFunc = ins->functions().constFirst(); QVERIFY(addedFunc->isUserAdded()); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction); @@ -88,7 +88,7 @@ void TestNestedTypes::testNestedTypesModifications() const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass")); QVERIFY(ins); QCOMPARE(sc->functions().count(), 2); // default constructor and removed method - AbstractMetaFunction *removedFunc = sc->functions().constLast(); + const auto removedFunc = sc->functions().constLast(); QVERIFY(removedFunc->isModifiedRemoved()); } diff --git a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp index d613074fe..de2f30135 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp @@ -50,9 +50,8 @@ void TestNumericalTypedef::testNumericalTypedef() QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 2); - const AbstractMetaFunction *funcDouble = builder->globalFunctions().constFirst(); - QVERIFY(funcDouble); - const AbstractMetaFunction *funcReal = builder->globalFunctions().constLast(); + auto funcDouble = builder->globalFunctions().constFirst(); + auto funcReal = builder->globalFunctions().constLast(); QVERIFY(funcReal); if (funcDouble->name() == QLatin1String("funcReal")) @@ -90,10 +89,8 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef() QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 2); - const AbstractMetaFunction *funcUnsignedShort = builder->globalFunctions().constFirst(); - QVERIFY(funcUnsignedShort); - const AbstractMetaFunction *funcUShort = builder->globalFunctions().constLast(); - QVERIFY(funcUShort); + auto funcUnsignedShort = builder->globalFunctions().constFirst(); + auto funcUShort = builder->globalFunctions().constLast(); if (funcUnsignedShort->name() == QLatin1String("funcUShort")) std::swap(funcUnsignedShort, funcUShort); diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp index 9f1e32e05..a589827e4 100644 --- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp @@ -55,8 +55,8 @@ void TestRefCountTag::testReferenceCountTag() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject")); - QVERIFY(func); + const auto func = classB->findFunction(QLatin1String("keepObject")); + QVERIFY(!func.isNull()); ReferenceCount refCount = func->modifications().constFirst().argument_mods().constFirst().referenceCounts.constFirst(); QCOMPARE(refCount.action, ReferenceCount::Add); } @@ -88,8 +88,8 @@ void TestRefCountTag::testWithApiVersion() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject")); - QVERIFY(func); + const auto func = classB->findFunction(QLatin1String("keepObject")); + QVERIFY(!func.isNull()); ReferenceCount refCount = func->modifications().constFirst().argument_mods().constFirst().referenceCounts.constFirst(); QCOMPARE(refCount.action, ReferenceCount::Add); diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp index 6cd719743..b929ebd66 100644 --- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp @@ -50,8 +50,8 @@ void TestReferenceToPointer::testReferenceToPointerArgument() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); QVERIFY(classB); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("dummy")); - QVERIFY(func); + const auto func = classB->findFunction(QLatin1String("dummy")); + QVERIFY(!func.isNull()); QCOMPARE(func->arguments().constFirst().type().minimalSignature(), QLatin1String("A*&")); } diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp index bd78ad80d..41103c24e 100644 --- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp @@ -62,7 +62,7 @@ void TestRemoveImplConv::testRemoveImplConv() QVERIFY(classB); const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C")); QVERIFY(classC); - AbstractMetaFunctionList implConv = classC->implicitConversions(); + const auto implConv = classC->implicitConversions(); QCOMPARE(implConv.count(), 1); QCOMPARE(implConv.constFirst()->arguments().constFirst().type().typeEntry(), classB->typeEntry()); diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp index 3b9936571..9824d1bf0 100644 --- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp @@ -106,8 +106,7 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod() removedSignatures.append(QLatin1String("operator>>(Char&)")); removedSignatures.append(QLatin1String("operator>>(String&)")); int notRemoved = classA->functions().size(); - const AbstractMetaFunctionList &functions = classA->functions(); - for (const AbstractMetaFunction *f : functions) { + for (const auto &f : classA->functions()) { QCOMPARE(f->isModifiedRemoved(), bool(removedSignatures.contains(f->minimalSignature()))); notRemoved -= int(f->isModifiedRemoved()); } diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp index 2203f3648..4c2930234 100644 --- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp @@ -58,7 +58,8 @@ void TestResolveType::testResolveReturnTypeFromParentScope() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("A::D")); QVERIFY(classD); - const AbstractMetaFunction* meth = classD->findFunction(QLatin1String("method")); + const auto meth = classD->findFunction(QLatin1String("method")); + QVERIFY(!meth.isNull()); QVERIFY(meth); } diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp index 66dd6edbf..3ad77c86f 100644 --- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp @@ -52,9 +52,9 @@ void TestReverseOperators::testReverseSum() QVERIFY(classA); QCOMPARE(classA->functions().count(), 4); - const AbstractMetaFunction* reverseOp = nullptr; - const AbstractMetaFunction* normalOp = 0; - for (const AbstractMetaFunction *func : classA->functions()) { + AbstractMetaFunctionCPtr reverseOp; + AbstractMetaFunctionCPtr normalOp; + for (const auto &func : classA->functions()) { if (func->name() == QLatin1String("operator+")) { if (func->isReverseOperator()) reverseOp = func; @@ -63,10 +63,10 @@ void TestReverseOperators::testReverseSum() } } - QVERIFY(normalOp); + QVERIFY(!normalOp.isNull()); QVERIFY(!normalOp->isReverseOperator()); QCOMPARE(normalOp->arguments().count(), 1); - QVERIFY(reverseOp); + QVERIFY(!reverseOp.isNull()); QVERIFY(reverseOp->isReverseOperator()); QCOMPARE(reverseOp->arguments().count(), 1); } @@ -98,9 +98,9 @@ void TestReverseOperators::testReverseSumWithAmbiguity() QVERIFY(classB); QCOMPARE(classB->functions().count(), 4); - const AbstractMetaFunction *reverseOp = nullptr; - const AbstractMetaFunction *normalOp = nullptr; - for (const AbstractMetaFunction *func : classB->functions()) { + AbstractMetaFunctionCPtr reverseOp; + AbstractMetaFunctionCPtr normalOp; + for (const auto &func : classB->functions()) { if (func->name() == QLatin1String("operator+")) { if (func->isReverseOperator()) reverseOp = func; @@ -108,11 +108,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity() normalOp = func; } } - QVERIFY(normalOp); + QVERIFY(!normalOp.isNull()); QVERIFY(!normalOp->isReverseOperator()); QCOMPARE(normalOp->arguments().count(), 1); QCOMPARE(normalOp->minimalSignature(), QLatin1String("operator+(B,A)")); - QVERIFY(reverseOp); + QVERIFY(!reverseOp.isNull()); QVERIFY(reverseOp->isReverseOperator()); QCOMPARE(reverseOp->arguments().count(), 1); QCOMPARE(reverseOp->minimalSignature(), QLatin1String("operator+(A,B)")); diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp index 2ddccc900..2a5bd750d 100644 --- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp @@ -77,7 +77,8 @@ namespace Internet { AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("Bookmarks")); QVERIFY(classB); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("list")); + const auto func = classB->findFunction(QLatin1String("list")); + QVERIFY(!func.isNull()); AbstractMetaType funcType = func->type(); QVERIFY(!funcType.isVoid()); QCOMPARE(funcType.cppSignature(), QLatin1String("QList<Internet::Url >")); @@ -116,7 +117,8 @@ namespace Namespace { QVERIFY(classB); QVERIFY(!classB->baseClass()); QVERIFY(classB->baseClassName().isEmpty()); - const AbstractMetaFunction* func = classB->findFunction(QLatin1String("foo")); + const auto func = classB->findFunction(QLatin1String("foo")); + QVERIFY(!func.isNull()); AbstractMetaType argType = func->arguments().constFirst().type(); QCOMPARE(argType.instantiations().count(), 1); QCOMPARE(argType.typeEntry()->qualifiedCppName(), QLatin1String("QList")); @@ -146,10 +148,10 @@ void func(List<int> arg) {} QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); + const auto globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction *func = globalFuncs.constFirst(); + const auto func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>)")); QCOMPARE(func->arguments().constFirst().type().cppSignature(), QLatin1String("List<int >")); @@ -171,10 +173,10 @@ void func(List<int>* arg) {} QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); + AbstractMetaFunctionCList globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction* func = globalFuncs.constFirst(); + const auto func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>*)")); QCOMPARE(func->arguments().constFirst().type().cppSignature(), QLatin1String("List<int > *")); @@ -196,10 +198,10 @@ void func(List<int>& arg) {} QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false)); QVERIFY(!builder.isNull()); - AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); + const auto globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction* func = globalFuncs.constFirst(); + const auto func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>&)")); QCOMPARE(func->arguments().constFirst().type().cppSignature(), QLatin1String("List<int > &")); @@ -230,13 +232,13 @@ struct List { QCOMPARE(templates.count(), 1); const AbstractMetaClass *list = templates.constFirst(); // Verify that the parameter of "void append(List l)" gets fixed to "List<T >" - const AbstractMetaFunction *append = list->findFunction(QStringLiteral("append")); - QVERIFY(append); + const auto append = list->findFunction(QStringLiteral("append")); + QVERIFY(!append.isNull()); QCOMPARE(append->arguments().size(), 1); QCOMPARE(append->arguments().at(0).type().cppSignature(), QLatin1String("List<T >")); // Verify that the parameter of "void erase(Iterator)" is not modified - const AbstractMetaFunction *erase = list->findFunction(QStringLiteral("erase")); - QVERIFY(erase); + const auto erase = list->findFunction(QStringLiteral("erase")); + QVERIFY(!erase.isNull()); QCOMPARE(erase->arguments().size(), 1); QEXPECT_FAIL("", "Clang: Some other code changes the parameter type", Abort); QCOMPARE(erase->arguments().at(0).type().cppSignature(), QLatin1String("List::Iterator")); @@ -438,12 +440,12 @@ typedef Vector<int> IntVector; ContainerTypeEntry::VectorContainer); QCOMPARE(vector->functions().count(), 4); - const AbstractMetaFunction* method = vector->findFunction(QLatin1String("method")); - QVERIFY(method); + const auto method = vector->findFunction(QLatin1String("method")); + QVERIFY(!method.isNull()); QCOMPARE(method->signature(), QLatin1String("method(const Vector<int > & vector)")); - const AbstractMetaFunction* otherMethod = vector->findFunction(QLatin1String("otherMethod")); - QVERIFY(otherMethod); + const auto otherMethod = vector->findFunction(QLatin1String("otherMethod")); + QVERIFY(!otherMethod.isNull()); QCOMPARE(otherMethod->signature(), QLatin1String("otherMethod()")); QVERIFY(!otherMethod->type().isVoid()); QCOMPARE(otherMethod->type().cppSignature(), QLatin1String("Vector<int >")); @@ -572,15 +574,13 @@ void TestTemplates::testTemplateTypeDefs() QCOMPARE(xmlOptionalInt->templateBaseClass(), optional); // Check whether the value() method now has an 'int' return - const AbstractMetaFunction *valueMethod = - optionalInt->findFunction(QLatin1String("value")); - QVERIFY(valueMethod); + const auto valueMethod = optionalInt->findFunction(QLatin1String("value")); + QVERIFY(!valueMethod.isNull()); QCOMPARE(valueMethod->type().cppSignature(), QLatin1String("int")); // ditto for typesystem XML - const AbstractMetaFunction *xmlValueMethod = - xmlOptionalInt->findFunction(QLatin1String("value")); - QVERIFY(xmlValueMethod); + const auto xmlValueMethod = xmlOptionalInt->findFunction(QLatin1String("value")); + QVERIFY(!xmlValueMethod.isNull()); QCOMPARE(xmlValueMethod->type().cppSignature(), QLatin1String("int")); // Check whether the m_value field is of type 'int' diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp index d39819d0f..6d155dacc 100644 --- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp @@ -45,7 +45,8 @@ void TestVoidArg::testVoidParsedFunction() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a")); + const auto addedFunc = classA->findFunction(QLatin1String("a")); + QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().count(), 0); } @@ -63,7 +64,8 @@ void TestVoidArg::testVoidAddedFunction() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a")); + const auto addedFunc = classA->findFunction(QLatin1String("a")); + QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().count(), 0); } @@ -80,7 +82,8 @@ void TestVoidArg::testVoidPointerParsedFunction() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("a")); + const auto addedFunc = classA->findFunction(QLatin1String("a")); + QVERIFY(!addedFunc.isNull()); QCOMPARE(addedFunc->arguments().count(), 1); } |