shiboken6: Add target-to-native conversion rules for smart pointers

Make it possible to construct for example a std::optional<int>
directly from a PyLong, which helps avoiding exposing
std::optional<int> as a type.

Task-number: PYSIDE-3107
Change-Id: I0e600fa04119ea944ef256da1f06df5f86cc9a50
Reviewed-by: Cristian Maureira-Fredes <[email protected]>

Author: FriedemannKleint

sources/shiboken6/ApiExtractor/customconversion.cpp

@@ -5,6 +5,7 @@
 #include "containertypeentry.h"
 #include "customtypenentry.h"
 #include "primitivetypeentry.h"
+#include "smartpointertypeentry.h"
 #include "valuetypeentry.h"
 
 #include <QtCore/qdebug.h>
@@ -139,6 +140,8 @@ CustomConversionPtr CustomConversion::getCustomConversion(const TypeEntryCPtr &t
         return std::static_pointer_cast<const ContainerTypeEntry>(type)->customConversion();
     if (type->isValue())
         return std::static_pointer_cast<const ValueTypeEntry>(type)->customConversion();
+    if (type->isSmartPointer())
+        return std::static_pointer_cast<const SmartPointerTypeEntry>(type)->customConversion();
     return {};
 }
 

sources/shiboken6/ApiExtractor/smartpointertypeentry.h

@@ -5,6 +5,7 @@
 #define SMARTPOINTERTYPEENTRY_H
 
 #include "complextypeentry.h"
+#include "customconversion_typedefs.h"
 
 class SmartPointerTypeEntryPrivate;
 
@@ -51,6 +52,10 @@ class SmartPointerTypeEntry : public ComplexTypeEntry
 
     QString getTargetName(const AbstractMetaType &metaType) const;
 
+    bool hasCustomConversion() const;
+    void setCustomConversion(const CustomConversionPtr &customConversion);
+    CustomConversionPtr customConversion() const;
+
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const override;
 #endif

sources/shiboken6/ApiExtractor/typesystem.cpp

@@ -2154,6 +2154,7 @@ class SmartPointerTypeEntryPrivate : public ComplexTypeEntryPrivate
     QString m_resetMethod;
     SmartPointerTypeEntry::Instantiations m_instantiations;
     TypeEntryCList m_excludedInstantiations;
+    CustomConversionPtr m_customConversion;
     TypeSystem::SmartPointerType m_smartPointerType;
 };
 
@@ -2306,6 +2307,24 @@ QString SmartPointerTypeEntry::getTargetName(const AbstractMetaType &metaType) c
     return fixSmartPointerName(name);
 }
 
+bool SmartPointerTypeEntry::hasCustomConversion() const
+{
+    S_D(const SmartPointerTypeEntry);
+    return bool(d->m_customConversion);
+}
+
+void SmartPointerTypeEntry::setCustomConversion(const CustomConversionPtr &customConversion)
+{
+    S_D(SmartPointerTypeEntry);
+    d->m_customConversion = customConversion;
+}
+
+CustomConversionPtr SmartPointerTypeEntry::customConversion() const
+{
+    S_D(const SmartPointerTypeEntry);
+    return d->m_customConversion;
+}
+
 // ----------------- NamespaceTypeEntry
 class NamespaceTypeEntryPrivate : public ComplexTypeEntryPrivate
 {

sources/shiboken6/ApiExtractor/typesystemparser.cpp

@@ -2348,9 +2348,10 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
     if (topElement != StackElement::ModifyArgument
         && topElement != StackElement::ValueTypeEntry
         && topElement != StackElement::PrimitiveTypeEntry
-        && topElement != StackElement::ContainerTypeEntry) {
+        && topElement != StackElement::ContainerTypeEntry
+        && topElement != StackElement::SmartPointerTypeEntry) {
         m_error = u"Conversion rules can only be specified for argument modification, "
-                   "value-type, primitive-type or container-type conversion."_s;
+                   "value-type, primitive-type, or container-type or smartpointer-type conversion."_s;
         return false;
     }
 
@@ -2415,6 +2416,9 @@ bool TypeSystemParser::parseCustomConversion(const ConditionalStreamReader &,
         std::static_pointer_cast<ContainerTypeEntry>(top->entry)->setCustomConversion(customConversion);
     else if (top->entry->isValue())
         std::static_pointer_cast<ValueTypeEntry>(top->entry)->setCustomConversion(customConversion);
+    else if (top->entry->isSmartPointer())
+        std::static_pointer_cast<SmartPointerTypeEntry>(top->entry)->setCustomConversion(customConversion);
+
     customConversionsForReview.append(customConversion);
     return true;
 }

sources/shiboken6/doc/typesystem_conversionrule.rst

@@ -12,9 +12,13 @@ The **conversion-rule** tag specifies how a **primitive-type**, a **container-ty
 or a **value-type** may be converted to and from the native C++ language types to the
 target language types (see also :ref:`user-defined-type-conversion`).
 
-It is a child of the :ref:`container-type`, :ref:`primitive-type` or
-:ref:`value-type` and may contain :ref:`native-to-target` or
-:ref:`native-to-target` child nodes.
+It may be a child of the :ref:`container-type` and :ref:`primitive-type` nodes,
+where conversions have to be provided for both directions using the
+:ref:`native-to-target` and :ref:`target-to-native` child nodes.
+
+It may also appear as a child of :ref:`value-type` or :ref:`smart-pointer-type`
+where additional conversions from other target language types can be provided
+using the :ref:`target-to-native` child node.
 
 .. code-block:: xml
 
@@ -70,8 +74,9 @@ an input value an does what's needed to convert it to the output value.
     </conversion-rule>
 
 Use the replace node to modify the template code.
-Notice that the generator must provide type system variables for the input
-and output values and types, namely **%in**, **%out**, **%INTYPE** and
+Notice that the generator provides type system variables for the input
+and output values and types (see :ref:`converter_variables_and_functions`).
+The most important ones are **%in**, **%out**, **%INTYPE** and
 **%OUTTYPE**. In the case of container types, **%INTYPE** refers to the
 full container type (e.g. **"list<int>"**) and **%INTYPE_0**, **%INTYPE_1**,
 **%INTYPE_#**, should be replaced by the types used in the container template

sources/shiboken6/doc/typesystem_specifying_types.rst

@@ -729,7 +729,8 @@ The ``smart pointer`` type node indicates that the given class is a smart pointe
 and requires inserting calls to **getter** to access the pointeee.
 Currently, the usage is limited to function return values.
 **ref-count-method** specifies the name of the method used to do reference counting.
-It is a child of the :ref:`typesystem_details` node or other type nodes.
+It is a child of the :ref:`typesystem_details` node or other type nodes
+and may contain :ref:`conversion-rule` nodes.
 
 The *optional* attribute **instantiations** specifies for which instantiations
 of the smart pointer wrappers will be generated (comma-separated list).

sources/shiboken6/generator/shiboken/cppgenerator.cpp

@@ -3618,13 +3618,15 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
     writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck);
 }
 
-void CppGenerator::writePythonToCppConversionFunctions(TextStream &s, const AbstractMetaType &containerType) const
+void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
+                                                       const AbstractMetaType &templateType) const
 {
-    Q_ASSERT(containerType.typeEntry()->isContainer());
-    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);
+    const auto customConversion = CustomConversion::getCustomConversion(templateType.typeEntry());
+    if (customConversion) {
+        const auto &conversions = customConversion->targetToNativeConversions();
+        for (const auto &conv : conversions)
+            writePythonToCppConversionFunction(s, templateType, conv);
+    }
 }
 
 void CppGenerator::writePythonToCppConversionFunction(TextStream &s,

sources/shiboken6/generator/shiboken/cppgenerator.h

@@ -364,9 +364,10 @@ class CppGenerator : public ShibokenGenerator
                                              const TargetToNativeConversion &toNative,
                                              const TypeEntryCPtr &targetType) const;
 
-    /// Writes a pair of Python to C++ conversion and check functions for instantiated container types.
+    /// Writes a pair of Python to C++ conversion and check functions for instantiated
+    /// template (smart pointer/container types).
     void writePythonToCppConversionFunctions(TextStream &s,
-                                             const AbstractMetaType &containerType) const;
+                                             const AbstractMetaType &templateType) const;
 
     void writePythonToCppConversionFunction(TextStream &s,
                                             const AbstractMetaType &containerType,

sources/shiboken6/generator/shiboken/cppgenerator_smartpointer.cpp

@@ -232,13 +232,16 @@ void CppGenerator::generateSmartPointerClass(TextStream &s,
 void CppGenerator::writeSmartPointerConverterFunctions(TextStream &s,
                                                        const AbstractMetaType &smartPointerType) const
 {
+    auto smartPointerTypeEntry =
+        std::static_pointer_cast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
+
+    if (smartPointerTypeEntry->hasCustomConversion())
+        writePythonToCppConversionFunctions(s, smartPointerType);
+
     const auto baseClasses = findSmartPointeeBaseClasses(api(), smartPointerType);
     if (baseClasses.isEmpty())
         return;
 
-    auto smartPointerTypeEntry =
-        std::static_pointer_cast<const SmartPointerTypeEntry>(smartPointerType.typeEntry());
-
     // TODO: Missing conversion to smart pointer pointer type:
 
     s << "// Register smartpointer conversion for all derived classes\n";
@@ -290,6 +293,8 @@ void CppGenerator::writeSmartPointerConverterInitialization(TextStream &s,
         writeAddPythonToCppConversion(s, targetConverter, toCpp, isConv);
     };
 
+    writeTemplateCustomConverterRegister(s, type);
+
     const auto classes = findSmartPointeeBaseClasses(api(), type);
     if (classes.isEmpty())
         return;