shiboken6: Port from QSharedPointer to std::shared_ptr

Task-number: QTBUG-109570
Change-Id: Iabdafb0a5ab211e32c1bbf7face78fd5102a49b9
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

7 files changed, 103 insertions, 101 deletions

diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index fd07684a5..72b7bc760 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -163,7 +163,7 @@ const ProtocolEntries &sequenceProtocols()
 static QString opaqueContainerCreationFunc(const AbstractMetaType &type)
 {
     const auto containerTypeEntry =
-        qSharedPointerCast<const ContainerTypeEntry>(type.typeEntry());
+        std::static_pointer_cast<const ContainerTypeEntry>(type.typeEntry());
     const auto instantiationTypeEntry =
         type.instantiations().constFirst().typeEntry();
     QString result = u"create"_s;
@@ -262,12 +262,12 @@ CppGenerator::BoolCastFunctionOptional
 {
     const auto te = metaClass->typeEntry();
     if (te->isSmartPointer()) {
-        auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te);
+        auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(te);
 
         auto valueCheckMethod = ste->valueCheckMethod();
         if (!valueCheckMethod.isEmpty()) {
             const auto func = metaClass->findFunction(valueCheckMethod);
-            if (func.isNull())
+            if (!func)
                 throw Exception(msgMethodNotFound(metaClass, valueCheckMethod));
             return BoolCastFunction{func, false};
         }
@@ -275,7 +275,7 @@ CppGenerator::BoolCastFunctionOptional
         auto nullCheckMethod = ste->nullCheckMethod();
         if (!nullCheckMethod.isEmpty()) {
             const auto func = metaClass->findFunction(nullCheckMethod);
-            if (func.isNull())
+            if (!func)
                 throw Exception(msgMethodNotFound(metaClass, nullCheckMethod));
             return BoolCastFunction{func, true};
         }
@@ -285,7 +285,7 @@ CppGenerator::BoolCastFunctionOptional
     if (useOperatorBoolAsNbNonZero()
         ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
         const auto func = metaClass->findOperatorBool();
-        if (!func.isNull())
+        if (func)
             return BoolCastFunction{func, false};
     }
 
@@ -293,7 +293,7 @@ CppGenerator::BoolCastFunctionOptional
     if (useIsNullAsNbNonZero()
         ? mode != TypeSystem::BoolCast::Disabled : mode == TypeSystem::BoolCast::Enabled) {
         const auto func = metaClass->findQtIsNullMethod();
-        if (!func.isNull())
+        if (func)
             return BoolCastFunction{func, true};
     }
     return std::nullopt;
@@ -479,7 +479,7 @@ static bool generateRichComparison(const GeneratorContext &c)
 {
     const auto metaClass = c.metaClass();
     if (c.forSmartPointer()) {
-        auto te = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry());
+        auto te = std::static_pointer_cast<const SmartPointerTypeEntry>(metaClass->typeEntry());
         return te->smartPointerType() == TypeSystem::SmartPointerType::Shared;
     }
 
@@ -653,7 +653,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
         AbstractMetaClassCPtr context = metaClass->enclosingClass();
         while (context) {
             if (context->isNamespace() && !context->enclosingClass()
-                && qSharedPointerCast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) {
+                && std::static_pointer_cast<const NamespaceTypeEntry>(context->typeEntry())->generateUsing()) {
                 s << "\nusing namespace " << context->qualifiedCppName() << ";\n";
                 break;
             }
@@ -673,7 +673,7 @@ void CppGenerator::generateClass(TextStream &s, const GeneratorContext &classCon
 
     // python conversion rules
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         if (vte->hasTargetConversionRule()) {
             s << "// Python Conversion\n";
             s << vte->targetConversionRule() << '\n';
@@ -938,7 +938,7 @@ void CppGenerator::generateSmartPointerClass(TextStream &s, const GeneratorConte
 {
     s.setLanguage(TextStream::Language::Cpp);
     AbstractMetaClassCPtr metaClass = classContext.metaClass();
-    const auto typeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(metaClass->typeEntry());
+    const auto typeEntry = std::static_pointer_cast<const SmartPointerTypeEntry>(metaClass->typeEntry());
     const bool hasPointeeClass = classContext.pointeeClass() != nullptr;
     const auto smartPointerType = typeEntry->smartPointerType();
     const bool isValueHandle = smartPointerType ==TypeSystem::SmartPointerType::ValueHandle;
@@ -1132,7 +1132,7 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
     // SbkType would return null when the type is a container.
     auto typeEntry = func->type().typeEntry();
     if (typeEntry->isContainer()) {
-        const auto cte = qSharedPointerCast<const ContainerTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const ContainerTypeEntry>(typeEntry);
         switch (cte->containerKind()) {
         case ContainerTypeEntry::ListContainer:
             break;
@@ -1374,7 +1374,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
 
     const bool isAbstract = func->isAbstract();
     if (isAbstract && func->isModifiedRemoved()) {
-        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.data())));
+        qCWarning(lcShiboken, "%s", qPrintable(msgPureVirtualFunctionRemoved(func.get())));
         s << returnStatement << '\n' << outdent << "}\n\n";
         return;
     }
@@ -1813,7 +1813,7 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta
     s << '\n';
 
     // QFlags part.
-    if (auto flags = enumType->flags(); !flags.isNull()) {
+    if (auto flags = enumType->flags()) {
         const QString flagsCppTypeName = useSurrogateName
             ? cppTypeName : getFullTypeName(flags).trimmed();
         writeFlagsConverterFunctions(s, flags, typeName, flagsCppTypeName, pyTypeCheck);
@@ -1936,7 +1936,7 @@ return result;)";
         c << '*' << outPtr << " = *"
             << cpythonWrapperCPtr(typeEntry, pyInVariable) << ';';
     } else {
-        auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(typeEntry);
+        auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(typeEntry);
         const QString resetMethod = ste->resetMethod();
         c << "auto *ptr = " << outPtr << ";\n";
         c << "if (" << pyInVariable << " == Py_None)\n" << indent;
@@ -2027,7 +2027,7 @@ return result;)";
     }
 
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         writeCustomConverterFunctions(s, vte->customConversion());
     }
 }
@@ -2035,7 +2035,7 @@ return result;)";
 void CppGenerator::writeCustomConverterFunctions(TextStream &s,
                                                  const CustomConversionPtr &customConversion) const
 {
-    if (customConversion.isNull())
+    if (!customConversion)
         return;
     const TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty())
@@ -2160,7 +2160,7 @@ void CppGenerator::writeConverterRegister(TextStream &s, const AbstractMetaClass
     }
 
     if (typeEntry->isValue()) {
-        auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+        auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
         writeCustomConverterRegister(s, vte->customConversion(), u"converter"_s);
     }
 }
@@ -2169,7 +2169,7 @@ void CppGenerator::writeCustomConverterRegister(TextStream &s,
                                                 const CustomConversionPtr &customConversion,
                                                 const QString &converterVar)
 {
-    if (customConversion.isNull())
+    if (!customConversion)
         return;
     const TargetToNativeConversions &toCppConversions =
         customConversion->targetToNativeConversions();
@@ -2210,7 +2210,7 @@ void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
         return;
 
     auto smartPointerTypeEntry =
-        qSharedPointerCast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
+        std::static_pointer_cast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
 
     // TODO: Missing conversion to smart pointer pointer type:
 
@@ -2578,7 +2578,7 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
     // Disable argument count checks for QObject constructors to allow for
     // passing properties as KW args.
     const auto owner = rfunc->ownerClass();
-    bool isQObjectConstructor = !owner.isNull() && isQObject(owner)
+    bool isQObjectConstructor = owner && isQObject(owner)
         && rfunc->functionType() == AbstractMetaFunction::ConstructorFunction;
 
     if (usesNamedArguments && !isQObjectConstructor) {
@@ -2861,7 +2861,7 @@ static void checkTypeViability(const AbstractMetaFunctionCPtr &func)
 }
 
 void CppGenerator::writeTypeCheck(TextStream &s,
-                                  const QSharedPointer<OverloadDataNode> &overloadData,
+                                  const std::shared_ptr<OverloadDataNode> &overloadData,
                                   const QString &argumentName)
 {
     QSet<TypeEntryCPtr> numericTypes;
@@ -3142,7 +3142,7 @@ void CppGenerator::writeOverloadedFunctionDecisor(TextStream &s, const OverloadD
         s << "// " << i << ": ";
         if (func->isStatic())
             s << "static ";
-        if (const auto decl = func->declaringClass(); !decl.isNull())
+        if (const auto decl = func->declaringClass())
             s << decl->name() << "::";
         s << func->signatureComment() << '\n';
     }
@@ -3226,7 +3226,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         auto func = referenceFunction;
         for (const auto &child : children) {
             const auto defValFunc = child->getFunctionWithDefaultValue();
-            if (!defValFunc.isNull()) {
+            if (defValFunc) {
                 func = defValFunc;
                 break;
             }
@@ -3316,7 +3316,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
             s << indent << typeChecks.join(u"\n&& "_s) << outdent;
         }
         s << ") {\n" << indent;
-        writeOverloadedFunctionDecisorEngine(s, overloadData, child.data());
+        writeOverloadedFunctionDecisorEngine(s, overloadData, child.get());
         s << outdent << '}';
     }
     s << '\n';
@@ -3349,7 +3349,7 @@ static void writeDeprecationWarning(TextStream &s,
                                     CppGenerator::ErrorReturn errorReturn)
 {
     s << "Shiboken::Warnings::warnDeprecated(\"";
-    if (const auto cls = context.metaClass(); !cls.isNull())
+    if (const auto cls = context.metaClass())
         s << cls->name() << "\", ";
     // Check error in case "warning-as-error" is set.
     s << '"' << func->signature().replace(u"::"_s, u"."_s) << "\");\n"
@@ -3530,7 +3530,7 @@ QString CppGenerator::containerNativeToTargetTypeName(const ContainerTypeEntryCP
 void CppGenerator::writeCppToPythonFunction(TextStream &s, const AbstractMetaType &containerType) const
 {
     Q_ASSERT(containerType.typeEntry()->isContainer());
-    auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
+    auto cte = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
     if (!cte->hasCustomConversion()) {
         QString m;
         QTextStream(&m) << "Can't write the C++ to Python conversion function for container type '"
@@ -3670,7 +3670,7 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
 void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const AbstractMetaType &containerType) const
 {
     Q_ASSERT(containerType.typeEntry()->isContainer());
-    const auto cte = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
+    const auto cte = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
     const auto customConversion = cte->customConversion();
     for (const auto &conv : customConversion->targetToNativeConversions())
         writePythonToCppConversionFunction(s, containerType, conv);
@@ -3761,7 +3761,7 @@ static bool forceQObjectNamedArguments(const AbstractMetaFunctionCPtr &func)
     if (func->functionType() != AbstractMetaFunction::ConstructorFunction)
         return false;
     const auto owner = func->ownerClass();
-    Q_ASSERT(!owner.isNull());
+    Q_ASSERT(owner);
     if (!isQObject(owner))
         return false;
     const QString &name = owner->name();
@@ -3875,7 +3875,7 @@ CppGenerator::argumentClassFromIndex(const ApiExtractorResult &api,
     if (type.isVoid() || !te->isComplex())
         throw Exception(msgInvalidArgumentModification(func, argIndex));
     const auto result = AbstractMetaClass::findClass(api.classes(), te);
-    if (result.isNull())
+    if (!result)
         throw Exception(msgClassNotFound(te));
     return result;
 }
@@ -4284,7 +4284,7 @@ void CppGenerator::writeMethodCall(TextStream &s, const AbstractMetaFunctionCPtr
             if (ownership == TypeSystem::TargetLangOwnership) {
                 s << "getOwnership(" << pyArgName << ");";
             } else if (auto ac = argumentClassFromIndex(api(), func, argIndex);
-                       !ac.isNull() && ac->hasVirtualDestructor()) {
+                       ac && ac->hasVirtualDestructor()) {
                 s << "releaseOwnership(" << pyArgName << ");";
             } else {
                 s << "invalidate(" << pyArgName << ");";
@@ -4507,7 +4507,7 @@ void CppGenerator::writeEnumConverterInitialization(TextStream &s, const Abstrac
 
     s << outdent << "}\n";
 
-    if (auto flags = enumType->flags(); !flags.isNull())
+    if (auto flags = enumType->flags())
         writeFlagsConverterInitialization(s, flags);
 }
 
@@ -4519,7 +4519,7 @@ QString CppGenerator::writeContainerConverterInitialization(TextStream &s, const
     s << converter << " = Shiboken::Conversions::createConverter(";
 
     Q_ASSERT(type.typeEntry()->isContainer());
-    const auto typeEntry = qSharedPointerCast<const ContainerTypeEntry>(type.typeEntry());
+    const auto typeEntry = std::static_pointer_cast<const ContainerTypeEntry>(type.typeEntry());
 
     const QString targetTypeName = containerNativeToTargetTypeName(typeEntry);
     if (targetTypeName == cPyObjectT()) {
@@ -4565,7 +4565,7 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s, const
     if (classes.isEmpty())
         return;
 
-    auto smartPointerTypeEntry = qSharedPointerCast<const SmartPointerTypeEntry>(type.typeEntry());
+    auto smartPointerTypeEntry = std::static_pointer_cast<const SmartPointerTypeEntry>(type.typeEntry());
 
     s << "// Register SmartPointer converter for type '" << cppSignature << "'." << '\n'
        << "///////////////////////////////////////////////////////////////////////////////////////\n\n";
@@ -4775,7 +4775,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
 
     // class or some ancestor has multiple inheritance
     const auto miClass = getMultipleInheritingClass(metaClass);
-    if (!miClass.isNull()) {
+    if (miClass) {
         if (metaClass == miClass)
             writeMultipleInheritanceInitializerFunction(s, metaClass);
         writeSpecialCastFunction(s, metaClass);
@@ -4789,7 +4789,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
         tp_hash = u'&' + cpythonBaseName(metaClass) + u"_HashFunc"_s;
 
     const auto callOp = metaClass->findFunction(u"operator()");
-    if (!callOp.isNull() && !callOp->isModifiedRemoved())
+    if (callOp && !callOp->isModifiedRemoved())
         tp_call = u'&' + cpythonFunctionName(callOp);
 
     const QString typePtr = u"_"_s + className
@@ -4844,7 +4844,7 @@ void CppGenerator::writeMappingMethods(TextStream &s,
 {
     for (const auto & m : mappingProtocols()) {
         const auto func = metaClass->findFunction(m.name);
-        if (func.isNull())
+        if (!func)
             continue;
         QString funcName = cpythonFunctionName(func);
         CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
@@ -4868,7 +4868,7 @@ void CppGenerator::writeSequenceMethods(TextStream &s,
 
     for (const auto &seq : sequenceProtocols()) {
         const auto func = metaClass->findFunction(seq.name);
-        if (func.isNull())
+        if (!func)
             continue;
         injectedCode = true;
         QString funcName = cpythonFunctionName(func);
@@ -4910,7 +4910,7 @@ void CppGenerator::writeTypeAsSequenceDefinition(TextStream &s,
     QMap<QString, QString> funcs;
     for (const auto &seq : sequenceProtocols()) {
         const auto func = metaClass->findFunction(seq.name);
-        if (!func.isNull()) {
+        if (func) {
             funcs.insert(seq.name, u'&' + cpythonFunctionName(func));
             hasFunctions = true;
         }
@@ -4947,7 +4947,7 @@ void CppGenerator::writeTypeAsMappingDefinition(TextStream &s,
     QMap<QString, QString> funcs;
     for (const auto &m : mappingProtocols()) {
         const auto func = metaClass->findFunction(m.name);
-        if (!func.isNull()) {
+        if (func) {
             const QString entry = u"reinterpret_cast<void *>(&"_s
                                   + cpythonFunctionName(func) + u')';
             funcs.insert(m.name, entry);
@@ -5413,7 +5413,7 @@ static ComparisonOperatorList smartPointeeComparisons(const GeneratorContext &co
     }
 
     const auto pointeeClass = context.pointeeClass();
-    if (pointeeClass.isNull())
+    if (!pointeeClass)
         return {};
 
     ComparisonOperatorList result;
@@ -5445,7 +5445,7 @@ void CppGenerator::writeSmartPointerRichCompareFunction(TextStream &s,
 
     const auto te = context.preciseType().typeEntry();
     Q_ASSERT(te->isSmartPointer());
-    const auto ste = qSharedPointerCast<const SmartPointerTypeEntry>(te);
+    const auto ste = std::static_pointer_cast<const SmartPointerTypeEntry>(te);
 
     s << "const auto *" << selfPointeeVar << " = " << CPP_SELF_VAR
         << '.' << ste->getter() << "();\n";
@@ -5525,8 +5525,8 @@ QByteArrayList CppGenerator::methodDefinitionParameters(const OverloadData &over
     // METH_STATIC causes a crash when used for global functions (also from
     // invisible namespaces).
     const auto ownerClass = overloadData.referenceFunction()->ownerClass();
-    if (!ownerClass.isNull()
-        && !invisibleTopNamespaces().contains(qSharedPointerConstCast<AbstractMetaClass>(ownerClass))) {
+    if (ownerClass
+        && !invisibleTopNamespaces().contains(std::const_pointer_cast<AbstractMetaClass>(ownerClass))) {
         if (overloadData.hasStaticFunction())
             result.append(QByteArrayLiteral("METH_STATIC"));
         if (overloadData.hasClassMethod())
@@ -5673,11 +5673,11 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum
                                            ErrorReturn errorReturn) const
 {
     const auto enclosingClass = cppEnum.targetLangEnclosingClass();
-    const bool hasUpperEnclosingClass = !enclosingClass.isNull()
-                                        && !enclosingClass->targetLangEnclosingClass().isNull();
+    const bool hasUpperEnclosingClass = enclosingClass
+                                        && enclosingClass->targetLangEnclosingClass();
     EnumTypeEntryCPtr enumTypeEntry = cppEnum.typeEntry();
     QString enclosingObjectVariable;
-    if (!enclosingClass.isNull())
+    if (enclosingClass)
         enclosingObjectVariable = cpythonTypeName(enclosingClass);
     else if (hasUpperEnclosingClass)
         enclosingObjectVariable = u"enclosingClass"_s;
@@ -5692,7 +5692,7 @@ void CppGenerator::writeEnumInitialization(TextStream &s, const AbstractMetaEnum
     if (!cppEnum.isAnonymous()) {
         int packageLevel = packageName().count(u'.') + 1;
         FlagsTypeEntryPtr flags = enumTypeEntry->flags();
-        if (!flags.isNull()) {
+        if (flags) {
             // The following could probably be made nicer:
             // We need 'flags->flagsName()' with the full module/class path.
             QString fullPath = getClassTargetFullName(cppEnum);
@@ -5830,7 +5830,7 @@ void CppGenerator::writeFlagsToLong(TextStream &s, const AbstractMetaEnum &cppEn
 void CppGenerator::writeFlagsNonZero(TextStream &s, const AbstractMetaEnum &cppEnum)
 {
     FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    if (flagsEntry.isNull())
+    if (!flagsEntry)
         return;
     s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)\n";
     s << "{\n" << indent << "int val;\n";
@@ -5885,7 +5885,7 @@ void CppGenerator::writeFlagsBinaryOperator(TextStream &s, const AbstractMetaEnu
                                             const QString &pyOpName, const QString &cppOpName)
 {
     FlagsTypeEntryPtr flagsEntry = cppEnum.typeEntry()->flags();
-    Q_ASSERT(!flagsEntry.isNull());
+    Q_ASSERT(flagsEntry);
 
     s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName
         << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")\n{\n" << indent;
@@ -6124,7 +6124,7 @@ void CppGenerator::writeClassRegister(TextStream &s,
 
     // Fill multiple inheritance data, if needed.
     const auto miClass = getMultipleInheritingClass(metaClass);
-    if (!miClass.isNull()) {
+    if (miClass) {
         s << "MultipleInheritanceInitFunction func = ";
         if (miClass == metaClass) {
             s << multipleInheritanceInitializerFunctionName(miClass) << ";\n";
@@ -6235,7 +6235,7 @@ QtRegisterMetaType qtMetaTypeRegistration(const AbstractMetaClassCPtr &c)
 
     // Is there a "base" specification in some base class, meaning only the
     // base class is to be registered?
-    if (auto base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec); !base.isNull()) {
+    if (auto base = recurseClassHierarchy(c, hasQtMetaTypeRegistrationSpec)) {
         const auto baseSpec = base->typeEntry()->qtMetaTypeRegistration();
         if (baseSpec == TypeSystem::QtMetaTypeRegistration::BaseEnabled)
             return QtRegisterMetaType::None;
@@ -6409,7 +6409,7 @@ static QString smartPointerGetter(const GeneratorContext &context)
 {
     const auto te = context.metaClass()->typeEntry();
     Q_ASSERT(te->isSmartPointer());
-    return qSharedPointerCast<const SmartPointerTypeEntry>(te)->getter();
+    return std::static_pointer_cast<const SmartPointerTypeEntry>(te)->getter();
 }
 
 void CppGenerator::writeSmartPointerSetattroFunction(TextStream &s,
@@ -6624,7 +6624,7 @@ bool CppGenerator::finishGeneration()
     for (auto it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
         const AbstractMetaFunctionCList &overloads = it.value();
         for (const auto &func : overloads) {
-            if (auto te = func->typeEntry(); !te.isNull())
+            if (auto te = func->typeEntry())
                 includes.insert(te->include());
         }
 
@@ -6659,9 +6659,9 @@ bool CppGenerator::finishGeneration()
     for (const auto &smp : api().instantiatedSmartPointers()) {
         GeneratorContext context = contextForSmartPointer(smp.specialized, smp.type);
         const auto enclosingClass = context.metaClass()->enclosingClass();
-        auto enclosingTypeEntry = enclosingClass.isNull()
-            ? targetLangEnclosingEntry(smp.type.typeEntry())
-            : enclosingClass->typeEntry();
+        auto enclosingTypeEntry = enclosingClass
+            ? enclosingClass->typeEntry()
+            : targetLangEnclosingEntry(smp.type.typeEntry());
 
         writeInitFunc(s_classInitDecl, s_classPythonDefines,
                       getInitFunctionName(context),
@@ -6685,7 +6685,7 @@ bool CppGenerator::finishGeneration()
 
     const QList<CustomConversionPtr> &typeConversions = getPrimitiveCustomConversions();
     for (const auto &c : typeConversions) {
-        if (auto te = c->ownerType(); !te.isNull())
+        if (auto te = c->ownerType())
             includes.insert(te->include());
     }
 
@@ -6733,7 +6733,7 @@ bool CppGenerator::finishGeneration()
 
     TypeDatabase *typeDb = TypeDatabase::instance();
     TypeSystemTypeEntryCPtr moduleEntry = typeDb->defaultTypeSystemType();
-    Q_ASSERT(!moduleEntry.isNull());
+    Q_ASSERT(moduleEntry);
 
     s  << '\n';
     // Extra includes
@@ -7050,16 +7050,16 @@ static bool useParentHeuristics(const ApiExtractorResult &api,
     if (!ComplexTypeEntry::isParentManagementEnabled()) // FIXME PYSIDE 7: Remove this
         return true;
     const auto owner = func->ownerClass();
-    if (owner.isNull())
+    if (!owner)
         return false;
     auto ownerEntry = parentManagementEntry(owner);
-    if (ownerEntry.isNull())
+    if (!ownerEntry)
         return false;
     auto argTypeEntry = argType.typeEntry();
     if (!argTypeEntry->isComplex())
         return false;
     const auto argClass = AbstractMetaClass::findClass(api.classes(), argTypeEntry);
-    return !argClass.isNull() && parentManagementEntry(argClass) == ownerEntry;
+    return argClass && parentManagementEntry(argClass) == ownerEntry;
 }
 
 bool CppGenerator::writeParentChildManagement(TextStream &s, const AbstractMetaFunctionCPtr &func,
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.h b/sources/shiboken6/generator/shiboken/cppgenerator.h
index 04a92271e..0277c3a8f 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.h
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.h
@@ -11,7 +11,8 @@
 
 #include <QtCore/QFlags>
 #include <QtCore/QHash>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 class OverloadDataNode;
 class OverloadDataRootNode;
@@ -176,7 +177,7 @@ private:
                                bool isNumber = false, bool rejectNull = false);
     static void writeTypeCheck(TextStream &s, const QString &customType,
                         const QString &argumentName);
-    static void writeTypeCheck(TextStream& s, const QSharedPointer<OverloadDataNode> &overloadData,
+    static void writeTypeCheck(TextStream& s, const std::shared_ptr<OverloadDataNode> &overloadData,
                         const QString &argumentName);
 
     static void writeTypeDiscoveryFunction(TextStream &s,
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
index 38cb5b3c1..5955e8a66 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator_container.cpp
@@ -87,7 +87,7 @@ CppGenerator::OpaqueContainerData
 {
     OpaqueContainerData result;
     const auto &valueType = containerType.instantiations().constFirst();
-    const auto containerTypeEntry = qSharedPointerCast<const ContainerTypeEntry>(containerType.typeEntry());
+    const auto containerTypeEntry = std::static_pointer_cast<const ContainerTypeEntry>(containerType.typeEntry());
     result.name = containerTypeEntry->opaqueContainerName(valueType.typeEntry()->name());
 
     const auto cppSignature = containerType.cppSignature();
diff --git a/sources/shiboken6/generator/shiboken/headergenerator.cpp b/sources/shiboken6/generator/shiboken/headergenerator.cpp
index 625ab0be7..d1a36c700 100644
--- a/sources/shiboken6/generator/shiboken/headergenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/headergenerator.cpp
@@ -277,10 +277,10 @@ void HeaderGenerator::writeMemberFunctionWrapper(TextStream &s,
         const auto &type = arg.type();
         TypeEntryCPtr enumTypeEntry;
         if (type.isFlags())
-            enumTypeEntry = qSharedPointerCast<const FlagsTypeEntry>(type.typeEntry())->originator();
+            enumTypeEntry = std::static_pointer_cast<const FlagsTypeEntry>(type.typeEntry())->originator();
         else if (type.isEnum())
             enumTypeEntry = type.typeEntry();
-        if (!enumTypeEntry.isNull()) {
+        if (enumTypeEntry) {
             s << type.cppSignature() << '(' << arg.name() << ')';
         } else if (type.passByValue() && type.isUniquePointer()) {
             s << stdMove(arg.name());
@@ -381,7 +381,7 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR
         // For a typedef "using Foo=QList<int>", write a type index
         // SBK_QLIST_INT besides SBK_FOO which is then matched by function
         // argument. Check against duplicate typedefs for the same types.
-        const auto cType = qSharedPointerCast<const ComplexTypeEntry>(typeEntry);
+        const auto cType = std::static_pointer_cast<const ComplexTypeEntry>(typeEntry);
         if (cType->baseContainerType()) {
             auto metaClass = AbstractMetaClass::findClass(api.classes(), cType);
             Q_ASSERT(metaClass != nullptr);
@@ -397,7 +397,7 @@ void HeaderGenerator::writeTypeIndexValueLine(TextStream &s, const ApiExtractorR
         }
     }
     if (typeEntry->isEnum()) {
-        auto ete = qSharedPointerCast<const EnumTypeEntry>(typeEntry);
+        auto ete = std::static_pointer_cast<const EnumTypeEntry>(typeEntry);
         if (ete->flags())
             writeTypeIndexValueLine(s, api, ete->flags());
     }
@@ -453,7 +453,7 @@ static bool canForwardDeclare(const AbstractMetaClassCPtr &c)
         || !c->innerClasses().isEmpty() || c->isTypeDef()) {
         return false;
     }
-    if (auto encl = c->enclosingClass(); !encl.isNull())
+    if (auto encl = c->enclosingClass())
         return encl->isNamespace();
     return true;
 }
@@ -521,14 +521,14 @@ static void writeForwardDeclarations(TextStream &s,
     NameSpaces nameSpaces;
 
     for (const auto &c : classList) {
-        if (auto encl = c->enclosingClass(); !encl.isNull()) {
+        if (auto encl = c->enclosingClass()) {
             Q_ASSERT(encl->isNamespace());
             auto idx = indexOf(nameSpaces, encl);
             if (idx != -1) {
                 nameSpaces[idx].classes.append(c);
             } else {
                 nameSpaces.append(NameSpace{encl, {c}});
-                for (auto enclNsp = encl->enclosingClass(); !enclNsp.isNull();
+                for (auto enclNsp = encl->enclosingClass(); enclNsp;
                      enclNsp = enclNsp->enclosingClass()) {
                     idx = indexOf(nameSpaces, enclNsp);
                     if (idx == -1)
@@ -835,7 +835,7 @@ void HeaderGenerator::writeSbkTypeFunction(TextStream &s, const AbstractMetaEnum
     s << "{ return " << cpythonTypeNameExt(cppEnum.typeEntry()) << "; }\n";
 
     const auto flag = cppEnum.typeEntry()->flags();
-    if (!flag.isNull()) {
+    if (flag) {
         s <<  "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() "
           << "{ return " << cpythonTypeNameExt(flag) << "; }\n";
     }
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp
index 72bcc6562..948c9c944 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.cpp
+++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp
@@ -475,13 +475,13 @@ OverloadDataNode *OverloadDataRootNode::addOverloadDataNode(const AbstractMetaFu
         }
     }
 
-    if (overloadData.isNull()) {
+    if (!overloadData) {
         const int argpos = argPos() + 1;
         overloadData.reset(new OverloadDataNode(func, this, arg, argpos));
         m_children.append(overloadData);
     }
 
-    return overloadData.data();
+    return overloadData.get();
 }
 
 bool OverloadData::hasNonVoidReturnType() const
@@ -604,7 +604,7 @@ const AbstractMetaArgument *OverloadDataNode::overloadArgument(const AbstractMet
 bool OverloadDataRootNode::nextArgumentHasDefaultValue() const
 {
     for (const auto &overloadData : m_children) {
-        if (!overloadData->getFunctionWithDefaultValue().isNull())
+        if (overloadData->getFunctionWithDefaultValue())
             return true;
     }
     return false;
@@ -612,13 +612,13 @@ bool OverloadDataRootNode::nextArgumentHasDefaultValue() const
 
 static const OverloadDataRootNode *_findNextArgWithDefault(const OverloadDataRootNode *overloadData)
 {
-    if (!overloadData->getFunctionWithDefaultValue().isNull())
+    if (overloadData->getFunctionWithDefaultValue())
         return overloadData;
 
     const OverloadDataRootNode *result = nullptr;
     const OverloadDataList &data = overloadData->children();
     for (const auto &odata : data) {
-        const auto *tmp = _findNextArgWithDefault(odata.data());
+        const auto *tmp = _findNextArgWithDefault(odata.get());
         if (!result || (tmp && result->argPos() > tmp->argPos()))
             result = tmp;
     }
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.h b/sources/shiboken6/generator/shiboken/overloaddata.h
index 3fc9eef50..128f7ccb3 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.h
+++ b/sources/shiboken6/generator/shiboken/overloaddata.h
@@ -9,13 +9,14 @@
 
 #include <QtCore/QBitArray>
 #include <QtCore/QList>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QTextStream)
 
 class OverloadDataNode;
-using OverloadDataNodePtr = QSharedPointer<OverloadDataNode>;
+using OverloadDataNodePtr = std::shared_ptr<OverloadDataNode>;
 using OverloadDataList = QList<OverloadDataNodePtr>;
 
 /// The root node of OverloadData. It contains all functions
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 7c40b4ed1..55851e650 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -258,9 +258,9 @@ AbstractMetaFunctionCList ShibokenGenerator::implicitConversions(const TypeEntry
 {
     if (!generateImplicitConversions() || !t->isValue())
         return {};
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(t);
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(t);
     auto customConversion = vte->customConversion();
-    if (!customConversion.isNull() && customConversion->replaceOriginalTargetToNativeConversions())
+    if (customConversion && customConversion->replaceOriginalTargetToNativeConversions())
         return {};
 
     auto result = api().implicitConversions(t);
@@ -285,7 +285,7 @@ QString ShibokenGenerator::fullPythonClassName(const AbstractMetaClassCPtr &meta
 {
     QString fullClassName = metaClass->name();
     auto enclosing = metaClass->enclosingClass();
-    while (!enclosing.isNull()) {
+    while (enclosing) {
         if (NamespaceTypeEntry::isVisibleScope(enclosing->typeEntry()))
             fullClassName.prepend(enclosing->name() + u'.');
         enclosing = enclosing->enclosingClass();
@@ -474,7 +474,7 @@ QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntryCPtr &flagsEntry
 QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum)
 {
     const auto flags = metaEnum->typeEntry()->flags();
-    return flags.isNull() ? QString{} : cpythonFlagsName(flags);
+    return flags ? cpythonFlagsName(flags) : QString{};
 }
 
 QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClassCPtr &metaClass)
@@ -593,11 +593,11 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntryCPtr &type)
         baseName = ptype->hasTargetLangApiType()
                    ? ptype->targetLangApiName() : pythonPrimitiveTypeName(ptype->name());
     } else if (type->isEnum()) {
-        baseName = cpythonEnumName(qSharedPointerCast<const EnumTypeEntry>(type));
+        baseName = cpythonEnumName(std::static_pointer_cast<const EnumTypeEntry>(type));
     } else if (type->isFlags()) {
-        baseName = cpythonFlagsName(qSharedPointerCast<const FlagsTypeEntry>(type));
+        baseName = cpythonFlagsName(std::static_pointer_cast<const FlagsTypeEntry>(type));
     } else if (type->isContainer()) {
-        const auto ctype = qSharedPointerCast<const ContainerTypeEntry>(type);
+        const auto ctype = std::static_pointer_cast<const ContainerTypeEntry>(type);
         baseName = containerCpythonBaseName(ctype);
     } else {
         baseName = cPyObjectT();
@@ -664,8 +664,8 @@ QString ShibokenGenerator::converterObject(const TypeEntryCPtr &type)
     }
 
     /* the typedef'd primitive types case */
-    auto pte = qSharedPointerDynamicCast<const PrimitiveTypeEntry>(type);
-    if (pte.isNull()) {
+    auto pte = std::dynamic_pointer_cast<const PrimitiveTypeEntry>(type);
+    if (!pte) {
         qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName();
         return QString();
     }
@@ -734,7 +734,7 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction
 {
     QString op = Generator::pythonOperatorFunctionName(func->originalName());
     if (op.isEmpty()) {
-        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func.data());
+        qCWarning(lcShiboken).noquote().nospace() << msgUnknownOperator(func.get());
         return unknownOperator();
     }
     if (func->arguments().isEmpty()) {
@@ -764,7 +764,7 @@ static std::optional<TypeSystem::CPythonType>
     const auto cte = t->targetLangApiType();
     if (cte->type() != TypeEntry::PythonType)
         return {};
-    return qSharedPointerCast<const PythonTypeEntry>(cte)->cPythonType();
+    return std::static_pointer_cast<const PythonTypeEntry>(cte)->cPythonType();
 }
 
 bool ShibokenGenerator::isNumber(const TypeEntryCPtr &type)
@@ -820,7 +820,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
 {
     const auto typeEntry = metaType.typeEntry();
     if (typeEntry->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(typeEntry);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(typeEntry));
@@ -837,7 +837,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
     if (typeEntry->isContainer()) {
         QString typeCheck = u"Shiboken::Conversions::"_s;
         ContainerTypeEntry::ContainerKind type =
-            qSharedPointerCast<const ContainerTypeEntry>(typeEntry)->containerKind();
+            std::static_pointer_cast<const ContainerTypeEntry>(typeEntry)->containerKind();
         if (type == ContainerTypeEntry::ListContainer
             || type == ContainerTypeEntry::SetContainer) {
             const QString containerType = type == ContainerTypeEntry::SetContainer
@@ -888,7 +888,7 @@ QString ShibokenGenerator::cpythonCheckFunction(AbstractMetaType metaType)
 QString ShibokenGenerator::cpythonCheckFunction(TypeEntryCPtr type)
 {
     if (type->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(type);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(type);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(type));
@@ -917,7 +917,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntryCPtr &typ
         QString result = u"Shiboken::Conversions::"_s;
         bool isValue = false;
         if (type->isValue()) {
-            const auto cte = qSharedPointerCast<const ComplexTypeEntry>(type);
+            const auto cte = std::static_pointer_cast<const ComplexTypeEntry>(type);
             isValue = !cte->isValueTypeWithCopyConstructorOnly();
         }
         result += isValue ? u"isPythonToCppValueConvertible"_s
@@ -933,7 +933,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(AbstractMetaType metaTyp
 {
     const auto typeEntry = metaType.typeEntry();
     if (typeEntry->isCustom()) {
-        const auto cte = qSharedPointerCast<const CustomTypeEntry>(typeEntry);
+        const auto cte = std::static_pointer_cast<const CustomTypeEntry>(typeEntry);
         if (cte->hasCheckFunction())
             return cte->checkFunction();
         throw Exception(msgUnknownCheckFunction(typeEntry));
@@ -1408,7 +1408,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
             const QRegularExpressionMatch match = pyArgsRegexCheck.match(code);
             if (match.hasMatch()) {
                 qCWarning(lcShiboken).noquote().nospace()
-                    << msgWrongIndex("%PYARG", match.captured(1), func.data());
+                    << msgWrongIndex("%PYARG", match.captured(1), func.get());
                 return;
             }
             code.replace(u"%PYARG_1"_s, PYTHON_ARG);
@@ -1439,7 +1439,7 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
     while (rit.hasNext()) {
         QRegularExpressionMatch match = rit.next();
         qCWarning(lcShiboken).noquote().nospace()
-            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func.data());
+            << msgWrongIndex("%ARG#_TYPE", match.captured(1), func.get());
     }
 
     // Replace template variable for return variable name.
@@ -1900,7 +1900,7 @@ IncludeGroupList ShibokenGenerator::classIncludes(const AbstractMetaClassCPtr &m
     for (auto &f : implicitConvs) {
         if (f->isConversionOperator()) {
             const auto source = f->ownerClass();
-            Q_ASSERT(!source.isNull());
+            Q_ASSERT(source);
             result.back().append(source->typeEntry()->include());
         }
     }
@@ -1988,7 +1988,7 @@ static void removeConstOverloads(AbstractMetaFunctionCList *overloads)
         const auto &f = overloads->at(i);
         if (f->isConstant()) {
             for (qsizetype c = 0, size = overloads->size(); c < size; ++c) {
-                if (f->isConstOverloadOf(overloads->at(c).data())) {
+                if (f->isConstOverloadOf(overloads->at(c).get())) {
                     overloads->removeAt(i);
                     break;
                 }
@@ -2240,7 +2240,7 @@ QString
     ShibokenGenerator::getTypeAlternateTemplateIndexVariableName(const AbstractMetaClassCPtr &metaClass)
 {
     const auto templateBaseClass = metaClass->templateBaseClass();
-    Q_ASSERT(!templateBaseClass.isNull());
+    Q_ASSERT(templateBaseClass);
     QString result = u"SBK_"_s
         + _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName()).toUpper();
     for (const auto &instantiation : metaClass->templateBaseClassInstantiations())
@@ -2334,7 +2334,7 @@ void ShibokenGenerator::replaceTemplateVariables(QString &code,
                                                  const AbstractMetaFunctionCPtr &func) const
 {
     const auto cpp_class = func->ownerClass();
-    if (!cpp_class.isNull())
+    if (cpp_class)
         code.replace(u"%TYPE"_s, cpp_class->name());
 
     const AbstractMetaArgumentList &argument = func->arguments();