feature-select: Implement a selectable feature framework

This is the framework for selectable features.
There are no real features implemented.

Planned is a maximum of 8 features.
They are all implemented as a dummy for now.

The decision depends of the following setting at the beginning of
a module after PySide2 import:

    from __feature__ import <feature name>

For more info, see the Jira issue, section

    The Principle Of Selectable Features In PySide

Task-number: PYSIDE-1019
Change-Id: If355e9294b5c16090b39d30422a90ea9c8523390
Reviewed-by: Christian Tismer <tismer@stackless.com>

18 files changed, 796 insertions, 60 deletions

diff --git a/sources/pyside2/libpyside/CMakeLists.txt b/sources/pyside2/libpyside/CMakeLists.txt
index 31f68749a..d6b20c45a 100644
--- a/sources/pyside2/libpyside/CMakeLists.txt
+++ b/sources/pyside2/libpyside/CMakeLists.txt
@@ -40,6 +40,7 @@ endif()
 
 set(libpyside_SRC
     dynamicqmetaobject.cpp
+    feature_select.cpp
     signalmanager.cpp
     globalreceiverv2.cpp
     pysideclassinfo.cpp
@@ -125,6 +126,7 @@ endif()
 
 set(libpyside_HEADERS
     dynamicqmetaobject.h
+    feature_select.h
     pysideclassinfo.h
     pysideqenum.h
     pysidemacros.h
diff --git a/sources/pyside2/libpyside/feature_select.cpp b/sources/pyside2/libpyside/feature_select.cpp
new file mode 100644
index 000000000..b7234ad75
--- /dev/null
+++ b/sources/pyside2/libpyside/feature_select.cpp
@@ -0,0 +1,395 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt for Python.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "feature_select.h"
+
+#include <shiboken.h>
+#include <sbkstaticstrings.h>
+
+#include <QtCore/QtGlobal>
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PYSIDE-1019: Support switchable extensions
+//
+// This functionality is no longer implemented in the signature module, since
+// the PyCFunction getsets do not have to be modified any longer.
+// Instead, we simply exchange the complete class dicts. This is done in the
+// basewrapper.cpp file.
+//
+// This is the general framework of the switchable extensions.
+// A maximum of eight features is planned so far. This seems to be enough.
+// More features are possible, but then we must somehow register the
+// extra `select_id`s above 255.
+//
+
+/*****************************************************************************
+
+    How Does This Feature Selection Work?
+    -------------------------------------
+
+The basic idea is to replace the `tp_dict` of a QObject derived type.
+This way, we can replace the methods of the dict in no time.
+
+The crucial point to understand is how the `tp_dict` is actually accessed:
+When you type "QObject.__dict__", the descriptor of SbkObjectType_Type
+is called. This descriptor is per default unassigned, so the base class
+PyType_Type provides the tp_getset method `type_dict`:
+
+    static PyObject *
+    type_dict(PyTypeObject *type, void *context)
+    {
+        if (type->tp_dict == NULL) {
+            Py_RETURN_NONE;
+        }
+        return PyDictProxy_New(type->tp_dict);
+    }
+
+In order to change that, we need to insert our own version into SbkObjectType:
+
+    static PyObject *Sbk_TypeGet___dict__(PyTypeObject *type, void *context)
+    {
+        auto dict = type->tp_dict;
+        if (dict == NULL)
+            Py_RETURN_NONE;
+        if (SelectFeatureSet != nullptr)
+            dict = SelectFeatureSet(type);
+        return PyDictProxy_New(dict);
+    }
+
+This way, the Python function `type_ready()` does not fill in the default,
+but uses our modified version. It a similar way, we overwrite type_getattro
+with our own version, again in SbkObjectType, replacing the default of
+PyType_Type.
+
+Now we can exchange the dict with a customized version.
+We have our own derived type `ChameleonDict` with additional attributes.
+These allow us to create a ring of dicts which can be rotated to the actual
+needed dict version:
+
+Every dict has a field `select_id` which is selected by the `from __feature__`
+import. The dicts are cyclic connected by the `dict_ring` field.
+
+When a class dict is required, now always `SelectFeatureSet` is called, which
+looks into the `__name__` attribute of the active module and decides which
+version of `tp_dict` is needed. Then the right dict is searched in the ring
+and created if not already there.
+
+This is everything that the following code does.
+
+*****************************************************************************/
+
+
+namespace PySide { namespace FeatureSelector {
+
+using namespace Shiboken;
+
+static PyObject *getFeatureSelectID()
+{
+    static PyObject *zero = PyInt_FromLong(0);
+    static PyObject *feature_dict = GetFeatureDict();
+    // these things are all borrowed
+    PyObject *globals = PyEval_GetGlobals();
+    if (globals == nullptr)
+        return zero;
+    PyObject *modname = PyDict_GetItem(globals, PyMagicName::name());
+    if (modname == nullptr)
+        return zero;
+    PyObject *flag = PyDict_GetItem(feature_dict, modname);
+    if (flag == nullptr || !PyInt_Check(flag))  // int/long cheating
+        return zero;
+    return flag;
+}
+
+// Create a derived dict class
+static PyTypeObject *
+createDerivedDictType()
+{
+    // It is not easy to create a compatible dict object with the
+    // limited API. Easier is to use Python to create a derived
+    // type and to modify that a bit from the C code.
+    PyObject *ChameleonDict = PepRun_GetResult(R"CPP(if True:
+
+        class ChameleonDict(dict):
+            __slots__ = ("dict_ring", "select_id")
+
+        result = ChameleonDict
+
+        )CPP");
+    return reinterpret_cast<PyTypeObject *>(ChameleonDict);
+}
+
+static PyTypeObject *old_dict_type = Py_TYPE(PyType_Type.tp_dict);
+static PyTypeObject *new_dict_type = nullptr;
+
+static void ensureNewDictType()
+{
+    if (new_dict_type == nullptr) {
+        new_dict_type = createDerivedDictType();
+        if (new_dict_type == nullptr)
+            Py_FatalError("PySide2: Problem creating ChameleonDict");
+    }
+}
+
+static inline PyObject *nextInCircle(PyObject *dict)
+{
+    // returns a borrowed ref
+    assert(Py_TYPE(dict) != old_dict_type);
+    AutoDecRef next_dict(PyObject_GetAttr(dict, PyName::dict_ring()));
+    return next_dict;
+}
+
+static inline void setNextDict(PyObject *dict, PyObject *next_dict)
+{
+    assert(Py_TYPE(dict) != old_dict_type);
+    PyObject_SetAttr(dict, PyName::dict_ring(), next_dict);
+}
+
+static inline void setSelectId(PyObject *dict, PyObject *select_id)
+{
+    assert(Py_TYPE(dict) != old_dict_type);
+    PyObject_SetAttr(dict, PyName::select_id(), select_id);
+}
+
+static inline PyObject *getSelectId(PyObject *dict)
+{
+    assert(Py_TYPE(dict) != old_dict_type);
+    auto select_id = PyObject_GetAttr(dict, PyName::select_id());
+    return select_id;
+}
+
+static bool replaceClassDict(PyTypeObject *type)
+{
+    /*
+     * Replace the type dict by the derived ChameleonDict.
+     * This is mandatory for all type dicts when they are touched.
+     */
+    ensureNewDictType();
+    PyObject *dict = type->tp_dict;
+    auto ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
+    PyObject *new_dict = PyObject_CallObject(ob_ndt, nullptr);
+    if (new_dict == nullptr || PyDict_Update(new_dict, dict) < 0)
+        return false;
+    // Insert the default id. Cannot fail for small numbers.
+    AutoDecRef select_id(PyInt_FromLong(0));
+    setSelectId(new_dict, select_id);
+    // insert the dict into itself as ring
+    setNextDict(new_dict, new_dict);
+    // We have now an exact copy of the dict with a new type.
+    // Replace `__dict__` which usually has refcount 1 (but see cyclic_test.py)
+    Py_DECREF(type->tp_dict);
+    type->tp_dict = new_dict;
+    return true;
+}
+
+static bool addNewDict(PyTypeObject *type, PyObject *select_id)
+{
+    /*
+     * Add a new dict to the ring and set it as `type->tp_dict`.
+     * A 'false' return is fatal.
+     */
+    auto dict = type->tp_dict;
+    auto ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
+    auto new_dict = PyObject_CallObject(ob_ndt, nullptr);
+    if (new_dict == nullptr)
+        return false;
+    setSelectId(new_dict, select_id);
+    // insert the dict into the ring
+    auto next_dict = nextInCircle(dict);
+    setNextDict(dict, new_dict);
+    setNextDict(new_dict, next_dict);
+    type->tp_dict = new_dict;
+    return true;
+}
+
+static bool moveToFeatureSet(PyTypeObject *type, PyObject *select_id)
+{
+    /*
+     * Rotate the ring to the given `select_id` and return `true`.
+     * If not found, stay at the current position and return `false`.
+     */
+    auto initial_dict = type->tp_dict;
+    auto dict = initial_dict;
+    do {
+        dict = nextInCircle(dict);
+        AutoDecRef current_id(getSelectId(dict));
+        // This works because small numbers are singleton objects.
+        if (current_id == select_id) {
+            type->tp_dict = dict;
+            return true;
+        }
+    } while (dict != initial_dict);
+    type->tp_dict = initial_dict;
+    return false;
+}
+
+typedef bool(*FeatureProc)(PyTypeObject *type, PyObject *prev_dict);
+
+static FeatureProc *featurePointer = nullptr;
+
+static bool createNewFeatureSet(PyTypeObject *type, PyObject *select_id)
+{
+    /*
+     * Create a new feature set.
+     * A `false` return value is a fatal error.
+     *
+     * A FeatureProc sees an empty `type->tp_dict` and the previous dict
+     * content in `prev_dict`. It is responsible of filling `type->tp_dict`
+     * with modified content.
+     */
+    static auto small_1 = PyInt_FromLong(255);
+    Q_UNUSED(small_1);
+    static auto small_2 = PyInt_FromLong(255);
+    Q_UNUSED(small_2);
+    // make sure that small integers are cached
+    assert(small_1 != nullptr && small_1 == small_2);
+
+    static auto zero = PyInt_FromLong(0);
+    bool ok = moveToFeatureSet(type, zero);
+    Q_UNUSED(ok);
+    assert(ok);
+
+    AutoDecRef prev_dict(type->tp_dict);
+    Py_INCREF(prev_dict);
+    if (!addNewDict(type, select_id))
+        return false;
+    int id = PyInt_AsSsize_t(select_id);
+    if (id == -1)
+        return false;
+    FeatureProc *proc = featurePointer;
+    for (int idx = id; *proc != nullptr; ++proc, idx >>= 1) {
+        if (idx & 1) {
+            // clear the tp_dict that will get new content
+            PyDict_Clear(type->tp_dict);
+            // let the proc re-fill the tp_dict
+            if (!(*proc)(type, prev_dict))
+                return false;
+            // if there is still a step, prepare `prev_dict`
+            if (idx >> 1) {
+                prev_dict.reset(PyDict_Copy(type->tp_dict));
+                if (prev_dict.isNull())
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+
+static PyObject *SelectFeatureSet(PyTypeObject *type)
+{
+    /*
+     *  This is the main function of the module.
+     *  It just makes no sense to make the function public, because
+     *  Shiboken will assign it via a public hook of `basewrapper.cpp`.
+     */
+    if (Py_TYPE(type->tp_dict) == old_dict_type) {
+        // PYSIDE-1019: On first touch, we initialize the dynamic naming.
+        // The dict type will be replaced after the first call.
+        if (!replaceClassDict(type))
+            return nullptr;
+    }
+    PyObject *select_id = getFeatureSelectID();     // borrowed
+    AutoDecRef current_id(getSelectId(type->tp_dict));
+    if (select_id != current_id) {
+        if (!moveToFeatureSet(type, select_id))
+            if (!createNewFeatureSet(type, select_id)) {
+                Py_FatalError("failed to create a new feature set!");
+                return nullptr;
+            }
+    }
+    return type->tp_dict;
+}
+
+static bool feature_01_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_02_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_04_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_08_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_10_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_20_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_40_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+static bool feature_80_addDummyNames(PyTypeObject *type, PyObject *prev_dict);
+
+static FeatureProc featureProcArray[] = {
+    feature_01_addDummyNames,
+    feature_02_addDummyNames,
+    feature_04_addDummyNames,
+    feature_08_addDummyNames,
+    feature_10_addDummyNames,
+    feature_20_addDummyNames,
+    feature_40_addDummyNames,
+    feature_80_addDummyNames,
+    nullptr
+};
+
+void init()
+{
+    featurePointer = featureProcArray;
+    initSelectableFeature(SelectFeatureSet);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PYSIDE-1019: Support switchable extensions
+//
+//     Feature 0x01..0x80: A fake switchable option for testing
+//
+
+#define SIMILAR_FEATURE(xx)  \
+static bool feature_##xx##_addDummyNames(PyTypeObject *type, PyObject *prev_dict) \
+{ \
+    PyObject *dict = type->tp_dict; \
+    if (PyDict_Update(dict, prev_dict) < 0) \
+        return false; \
+    Py_INCREF(Py_None); \
+    if (PyDict_SetItemString(dict, "fake_feature_" #xx, Py_None) < 0) \
+        return false; \
+    return true; \
+}
+
+SIMILAR_FEATURE(01)
+SIMILAR_FEATURE(02)
+SIMILAR_FEATURE(04)
+SIMILAR_FEATURE(08)
+SIMILAR_FEATURE(10)
+SIMILAR_FEATURE(20)
+SIMILAR_FEATURE(40)
+SIMILAR_FEATURE(80)
+
+} // namespace PySide
+} // namespace FeatureSelector
diff --git a/sources/pyside2/libpyside/feature_select.h b/sources/pyside2/libpyside/feature_select.h
new file mode 100644
index 000000000..68e29292d
--- /dev/null
+++ b/sources/pyside2/libpyside/feature_select.h
@@ -0,0 +1,53 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt for Python.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef FEATURE_SELECT_H
+#define FEATURE_SELECT_H
+
+#include "pysidemacros.h"
+
+namespace PySide {
+namespace FeatureSelector {
+
+PYSIDE_API void init();
+
+} // namespace PySide
+} // namespace FeatureSelector
+
+#endif // FEATURE_SELECT_H
diff --git a/sources/pyside2/libpyside/pyside.cpp b/sources/pyside2/libpyside/pyside.cpp
index 66e931164..074fa764b 100644
--- a/sources/pyside2/libpyside/pyside.cpp
+++ b/sources/pyside2/libpyside/pyside.cpp
@@ -50,6 +50,7 @@
 #include "pysidemetafunction_p.h"
 #include "pysidemetafunction.h"
 #include "dynamicqmetaobject.h"
+#include "feature_select.h"
 
 #include <autodecref.h>
 #include <basewrapper.h>
@@ -93,6 +94,7 @@ void init(PyObject *module)
     MetaFunction::init(module);
     // Init signal manager, so it will register some meta types used by QVariant.
     SignalManager::instance();
+    FeatureSelector::init();
     initQApp();
 }
 
diff --git a/sources/pyside2/tests/QtCore/CMakeLists.txt b/sources/pyside2/tests/QtCore/CMakeLists.txt
index 7973a51ca..771e1aeef 100644
--- a/sources/pyside2/tests/QtCore/CMakeLists.txt
+++ b/sources/pyside2/tests/QtCore/CMakeLists.txt
@@ -37,6 +37,7 @@ PYSIDE_TEST(deletelater_test.py)
 PYSIDE_TEST(destroysignal_test.py)
 PYSIDE_TEST(duck_punching_test.py)
 PYSIDE_TEST(emoji_string_test.py)
+PYSIDE_TEST(feature_test.py)
 PYSIDE_TEST(hash_test.py)
 PYSIDE_TEST(inherits_test.py)
 PYSIDE_TEST(max_signals.py)
diff --git a/sources/pyside2/tests/QtCore/feature_test.py b/sources/pyside2/tests/QtCore/feature_test.py
new file mode 100644
index 000000000..cf1e8c3f2
--- /dev/null
+++ b/sources/pyside2/tests/QtCore/feature_test.py
@@ -0,0 +1,105 @@
+#############################################################################
+##
+## Copyright (C) 2020 The Qt Company Ltd.
+## Contact: https://www.qt.io/licensing/
+##
+## This file is part of Qt for Python.
+##
+## $QT_BEGIN_LICENSE:LGPL$
+## Commercial License Usage
+## Licensees holding valid commercial Qt licenses may use this file in
+## accordance with the commercial license agreement provided with the
+## Software or, alternatively, in accordance with the terms contained in
+## a written agreement between you and The Qt Company. For licensing terms
+## and conditions see https://www.qt.io/terms-conditions. For further
+## information use the contact form at https://www.qt.io/contact-us.
+##
+## GNU Lesser General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU Lesser
+## General Public License version 3 as published by the Free Software
+## Foundation and appearing in the file LICENSE.LGPL3 included in the
+## packaging of this file. Please review the following information to
+## ensure the GNU Lesser General Public License version 3 requirements
+## will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+##
+## GNU General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU
+## General Public License version 2.0 or (at your option) the GNU General
+## Public license version 3 or any later version approved by the KDE Free
+## Qt Foundation. The licenses are as published by the Free Software
+## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+## included in the packaging of this file. Please review the following
+## information to ensure the GNU General Public License requirements will
+## be met: https://www.gnu.org/licenses/gpl-2.0.html and
+## https://www.gnu.org/licenses/gpl-3.0.html.
+##
+## $QT_END_LICENSE$
+##
+#############################################################################
+
+import os
+import sys
+import unittest
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide2 import QtCore
+from PySide2.support.__feature__ import _really_all_feature_names
+from textwrap import dedent
+
+"""
+feature_test.py
+--------------
+
+This tests the selectable features in PySide.
+
+There are no real features implemented. They will be added, later.
+"""
+
+class FeaturesTest(unittest.TestCase):
+
+    def testAllFeatureCombinations(self):
+        """
+        Test for all 256 possible combinations of `__feature__` imports.
+        """
+        global __name__
+
+        for bit in range(8):
+            # We are cheating here, since the functions are in the globals.
+            exec(dedent("""
+
+        def tst_bit{0}(flag, self):
+            if flag == 0:
+                with self.assertRaises(AttributeError):
+                    QtCore.QCborArray.fake_feature_{1:02x}
+                with self.assertRaises(KeyError):
+                    QtCore.QCborArray.__dict__["fake_feature_{1:02x}"]
+            else:
+                QtCore.QCborArray.fake_feature_{1:02x}
+                QtCore.QCborArray.__dict__["fake_feature_{1:02x}"]
+
+                        """.format(bit, 1 << bit)), globals(), globals())
+        feature_list = _really_all_feature_names
+        func_list = [tst_bit0, tst_bit1, tst_bit2, tst_bit3,
+                     tst_bit4, tst_bit5, tst_bit6, tst_bit7]
+
+        for idx in range(0x100):
+            __name__ = "feature_{:02x}".format(idx)
+            print()
+            print("--- Feature Test Module `{}` ---".format(__name__))
+            print("Imports:")
+            for bit in range(8):
+                if idx & 1 << bit:
+                    feature = feature_list[bit]
+                    text = "from __feature__ import {}".format(feature)
+                    print(text)
+                    exec(text)
+            for bit in range(8):
+                value = idx & 1 << bit
+                func_list[bit](value, self=self)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/shiboken2/libshiboken/basewrapper.cpp b/sources/shiboken2/libshiboken/basewrapper.cpp
index 4c15582e9..5c2dc7807 100644
--- a/sources/shiboken2/libshiboken/basewrapper.cpp
+++ b/sources/shiboken2/libshiboken/basewrapper.cpp
@@ -95,12 +95,31 @@ void Sbk_object_dealloc(PyObject *self)
 static void SbkObjectTypeDealloc(PyObject *pyObj);
 static PyObject *SbkObjectTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds);
 
+static SelectableFeatureHook SelectFeatureSet = nullptr;
+
+void initSelectableFeature(SelectableFeatureHook func)
+{
+    SelectFeatureSet = func;
+}
+
+// PYSIDE-1019: Switch type's tp_dict to the currently active namespace.
+static PyObject *Sbk_TypeGet___dict__(PyTypeObject *type, void *context)
+{
+    auto dict = type->tp_dict;
+    if (dict == NULL)
+        Py_RETURN_NONE;
+    if (SelectFeatureSet != nullptr)
+        dict = SelectFeatureSet(type);
+    return PyDictProxy_New(dict);
+}
+
 // PYSIDE-908: The function PyType_Modified does not work in PySide, so we need to
 // explicitly pass __doc__. For __signature__ it _did_ actually work, because
 // it was not existing before. We add them both for clarity.
 static PyGetSetDef SbkObjectType_Type_getsetlist[] = {
     {const_cast<char *>("__signature__"), (getter)Sbk_TypeGet___signature__},
     {const_cast<char *>("__doc__"),       (getter)Sbk_TypeGet___doc__},
+    {const_cast<char *>("__dict__"),      (getter)Sbk_TypeGet___dict__},
     {nullptr}  // Sentinel
 };
 
@@ -121,8 +140,25 @@ static PyObject *SbkObjectType_repr(PyObject *type)
 
 #endif // PY_VERSION_HEX < 0x03000000
 
+// PYSIDE-1019: Switch type's tp_dict to the currently active namespace.
+static PyObject *(*type_getattro)(PyObject *type, PyObject *name);
+
+static PyObject *mangled_type_getattro(PyTypeObject *type, PyObject *name)
+{
+    /*
+     * Note: This `type_getattro` version is only the default that comes
+     * from `PyType_Type.tp_getattro`. This does *not* interfere in any way
+     * with the complex `tp_getattro` of `QObject` and other instances.
+     * What we change here is the meta class of `QObject`.
+     */
+    if (SelectFeatureSet != nullptr)
+        type->tp_dict = SelectFeatureSet(type);
+    return type_getattro(reinterpret_cast<PyObject *>(type), name);
+}
+
 static PyType_Slot SbkObjectType_Type_slots[] = {
     {Py_tp_dealloc, reinterpret_cast<void *>(SbkObjectTypeDealloc)},
+    {Py_tp_getattro, reinterpret_cast<void *>(mangled_type_getattro)},
     {Py_tp_setattro, reinterpret_cast<void *>(PyObject_GenericSetAttr)},
     {Py_tp_base, static_cast<void *>(&PyType_Type)},
     {Py_tp_alloc, reinterpret_cast<void *>(PyType_GenericAlloc)},
@@ -235,6 +271,9 @@ PyTypeObject *SbkObjectType_TypeF(void)
 {
     static PyTypeObject *type = nullptr;
     if (!type) {
+        // PYSIDE-1019: Insert the default tp_getattro explicitly here
+        //              so we can overwrite it a bit.
+        type_getattro = PyType_Type.tp_getattro;
         SbkObjectType_Type_spec.basicsize =
             PepHeapType_SIZE + sizeof(SbkObjectTypePrivate);
         type = reinterpret_cast<PyTypeObject *>(SbkType_FromSpec(&SbkObjectType_Type_spec));
diff --git a/sources/shiboken2/libshiboken/basewrapper.h b/sources/shiboken2/libshiboken/basewrapper.h
index 7248103cc..a4a8629fb 100644
--- a/sources/shiboken2/libshiboken/basewrapper.h
+++ b/sources/shiboken2/libshiboken/basewrapper.h
@@ -93,6 +93,9 @@ typedef void (*ObjectDestructor)(void *);
 
 typedef void (*SubTypeInitHook)(SbkObjectType *, PyObject *, PyObject *);
 
+typedef PyObject *(*SelectableFeatureHook)(PyTypeObject *);
+LIBSHIBOKEN_API void initSelectableFeature(SelectableFeatureHook func);
+
 extern LIBSHIBOKEN_API PyTypeObject *SbkObjectType_TypeF(void);
 extern LIBSHIBOKEN_API SbkObjectType *SbkObject_TypeF(void);
 
diff --git a/sources/shiboken2/libshiboken/pep384impl.cpp b/sources/shiboken2/libshiboken/pep384impl.cpp
index 5e0053e2e..4149bbcbf 100644
--- a/sources/shiboken2/libshiboken/pep384impl.cpp
+++ b/sources/shiboken2/libshiboken/pep384impl.cpp
@@ -78,14 +78,20 @@ static PyGetSetDef probe_getseters[] = {
     {nullptr}  /* Sentinel */
 };
 
+static PyMemberDef probe_members[] = {
+    {nullptr}  /* Sentinel */
+};
+
 #define probe_tp_dealloc    make_dummy(1)
 #define probe_tp_repr       make_dummy(2)
 #define probe_tp_call       make_dummy(3)
+#define probe_tp_getattro   make_dummy(16)
 #define probe_tp_str        make_dummy(4)
 #define probe_tp_traverse   make_dummy(5)
 #define probe_tp_clear      make_dummy(6)
 #define probe_tp_iternext   make_dummy(7)
 #define probe_tp_methods    probe_methoddef
+#define probe_tp_members    probe_members
 #define probe_tp_getset     probe_getseters
 #define probe_tp_descr_get  make_dummy(10)
 #define probe_tp_init       make_dummy(11)
@@ -101,11 +107,13 @@ static PyType_Slot typeprobe_slots[] = {
     {Py_tp_dealloc,     probe_tp_dealloc},
     {Py_tp_repr,        probe_tp_repr},
     {Py_tp_call,        probe_tp_call},
+    {Py_tp_getattro,    probe_tp_getattro},
     {Py_tp_str,         probe_tp_str},
     {Py_tp_traverse,    probe_tp_traverse},
     {Py_tp_clear,       probe_tp_clear},
     {Py_tp_iternext,    probe_tp_iternext},
     {Py_tp_methods,     probe_tp_methods},
+    {Py_tp_members,     probe_tp_members},
     {Py_tp_getset,      probe_tp_getset},
     {Py_tp_descr_get,   probe_tp_descr_get},
     {Py_tp_init,        probe_tp_init},
@@ -144,6 +152,7 @@ check_PyTypeObject_valid()
         || probe_tp_dealloc         != check->tp_dealloc
         || probe_tp_repr            != check->tp_repr
         || probe_tp_call            != check->tp_call
+        || probe_tp_getattro        != check->tp_getattro
         || probe_tp_str             != check->tp_str
         || probe_tp_traverse        != check->tp_traverse
         || probe_tp_clear           != check->tp_clear
@@ -427,27 +436,6 @@ PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
 
 #endif // Py_LIMITED_API
 
-// This is only a simple local helper that returns a computed variable.
-// Used also in Python 2.
-#if defined(Py_LIMITED_API) || defined(IS_PY2)
-static PyObject *
-PepRun_GetResult(const char *command)
-{
-    PyObject *d, *v, *res;
-
-    d = PyDict_New();
-    if (d == nullptr
-        || PyDict_SetItem(d, Shiboken::PyMagicName::builtins(), PyEval_GetBuiltins()) < 0) {
-        return nullptr;
-    }
-    v = PyRun_String(command, Py_file_input, d, d);
-    res = v ? PyDict_GetItem(d, Shiboken::PyName::result()) : nullptr;
-    Py_XDECREF(v);
-    Py_DECREF(d);
-    return res;
-}
-#endif // defined(Py_LIMITED_API) || defined(IS_PY2)
-
 /*****************************************************************************
  *
  * Support for classobject.h
@@ -669,6 +657,29 @@ PyImport_GetModule(PyObject *name)
 
 #endif // PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
 
+// 2020-06-16: For simplicity of creating arbitrary things, this function
+// is now made public.
+
+PyObject *
+PepRun_GetResult(const char *command)
+{
+    /*
+     * Evaluate a string and return the variable `result`
+     */
+    PyObject *d, *v, *res;
+
+    d = PyDict_New();
+    if (d == nullptr
+        || PyDict_SetItem(d, Shiboken::PyMagicName::builtins(), PyEval_GetBuiltins()) < 0) {
+        return nullptr;
+    }
+    v = PyRun_String(command, Py_file_input, d, d);
+    res = v ? PyDict_GetItem(d, Shiboken::PyName::result()) : nullptr;
+    Py_XDECREF(v);
+    Py_DECREF(d);
+    return res;
+}
+
 /*****************************************************************************
  *
  * Python 2 incompatibilities
diff --git a/sources/shiboken2/libshiboken/pep384impl.h b/sources/shiboken2/libshiboken/pep384impl.h
index 2bfe52254..2a14d6543 100644
--- a/sources/shiboken2/libshiboken/pep384impl.h
+++ b/sources/shiboken2/libshiboken/pep384impl.h
@@ -98,7 +98,7 @@ typedef struct _typeobject {
     void *X13; // hashfunc tp_hash;
     ternaryfunc tp_call;
     reprfunc tp_str;
-    void *X16; // getattrofunc tp_getattro;
+    getattrofunc tp_getattro;
     void *X17; // setattrofunc tp_setattro;
     void *X18; // PyBufferProcs *tp_as_buffer;
     unsigned long tp_flags;
@@ -110,7 +110,7 @@ typedef struct _typeobject {
     void *X25; // getiterfunc tp_iter;
     iternextfunc tp_iternext;
     struct PyMethodDef *tp_methods;
-    void *X28; // struct PyMemberDef *tp_members;
+    struct PyMemberDef *tp_members;
     struct PyGetSetDef *tp_getset;
     struct _typeobject *tp_base;
     PyObject *tp_dict;
@@ -531,6 +531,9 @@ extern LIBSHIBOKEN_API PyTypeObject *PepMethodDescr_TypePtr;
 LIBSHIBOKEN_API PyObject *PyImport_GetModule(PyObject *name);
 #endif // PY_VERSION_HEX < 0x03070000 || defined(Py_LIMITED_API)
 
+// Evaluate a script and return the variable `result`
+LIBSHIBOKEN_API PyObject *PepRun_GetResult(const char *command);
+
 /*****************************************************************************
  *
  * Python 2 incompatibilities
diff --git a/sources/shiboken2/libshiboken/sbkstaticstrings.cpp b/sources/shiboken2/libshiboken/sbkstaticstrings.cpp
index 541d74918..9dd98eef3 100644
--- a/sources/shiboken2/libshiboken/sbkstaticstrings.cpp
+++ b/sources/shiboken2/libshiboken/sbkstaticstrings.cpp
@@ -52,9 +52,11 @@ namespace Shiboken
 {
 namespace PyName {
 // exported:
+STATIC_STRING_IMPL(dict_ring, "dict_ring")
 STATIC_STRING_IMPL(dumps, "dumps")
 STATIC_STRING_IMPL(loads, "loads")
 STATIC_STRING_IMPL(result, "result")
+STATIC_STRING_IMPL(select_id, "select_id")
 STATIC_STRING_IMPL(value, "value")
 STATIC_STRING_IMPL(values, "values")
 
@@ -75,6 +77,7 @@ STATIC_STRING_IMPL(staticmethod, "staticmethod")
 namespace PyMagicName {
 // exported:
 STATIC_STRING_IMPL(class_, "__class__")
+STATIC_STRING_IMPL(dict, "__dict__")
 STATIC_STRING_IMPL(ecf, "__ecf__")
 STATIC_STRING_IMPL(file, "__file__")
 STATIC_STRING_IMPL(members, "__members__")
diff --git a/sources/shiboken2/libshiboken/sbkstaticstrings.h b/sources/shiboken2/libshiboken/sbkstaticstrings.h
index 4078d163c..ebb64579c 100644
--- a/sources/shiboken2/libshiboken/sbkstaticstrings.h
+++ b/sources/shiboken2/libshiboken/sbkstaticstrings.h
@@ -49,11 +49,13 @@ namespace Shiboken
 namespace PyName
 {
 LIBSHIBOKEN_API PyObject *co_name();
+LIBSHIBOKEN_API PyObject *dict_ring();
 LIBSHIBOKEN_API PyObject *dumps();
 LIBSHIBOKEN_API PyObject *f_code();
 LIBSHIBOKEN_API PyObject *f_lineno();
 LIBSHIBOKEN_API PyObject *loads();
 LIBSHIBOKEN_API PyObject *result();
+LIBSHIBOKEN_API PyObject *select_id();
 LIBSHIBOKEN_API PyObject *value();
 LIBSHIBOKEN_API PyObject *values();
 } // namespace PyName
@@ -61,6 +63,7 @@ LIBSHIBOKEN_API PyObject *values();
 namespace PyMagicName
 {
 LIBSHIBOKEN_API PyObject *class_();
+LIBSHIBOKEN_API PyObject *dict();
 LIBSHIBOKEN_API PyObject *ecf();
 LIBSHIBOKEN_API PyObject *file();
 LIBSHIBOKEN_API PyObject *members();
diff --git a/sources/shiboken2/libshiboken/shiboken.h b/sources/shiboken2/libshiboken/shiboken.h
index 0d2d6b0a6..3e1df5235 100644
--- a/sources/shiboken2/libshiboken/shiboken.h
+++ b/sources/shiboken2/libshiboken/shiboken.h
@@ -55,6 +55,7 @@
 #include "sbkstaticstrings.h"
 #include "shibokenmacros.h"
 #include "shibokenbuffer.h"
+#include "signature.h"
 
 #endif // SHIBOKEN_H
 
diff --git a/sources/shiboken2/libshiboken/signature.cpp b/sources/shiboken2/libshiboken/signature.cpp
index b09b68d47..4614a131e 100644
--- a/sources/shiboken2/libshiboken/signature.cpp
+++ b/sources/shiboken2/libshiboken/signature.cpp
@@ -74,8 +74,8 @@ typedef struct safe_globals_struc {
     PyObject *helper_module;
     PyObject *arg_dict;
     PyObject *map_dict;
-    PyObject *value_dict;   // for writing signatures
-    PyObject *feature_dict;  // registry for PySide.__feature__
+    PyObject *value_dict;       // for writing signatures
+    PyObject *feature_dict;     // registry for PySide.support.__feature__
     // init part 2: run module
     PyObject *pyside_type_init_func;
     PyObject *create_signature_func;
@@ -653,22 +653,17 @@ _fixup_getset(PyTypeObject *type, const char *name, PyGetSetDef *new_gsp)
             }
         }
     }
-    PyMemberDef *md = type->tp_members;
-    if (md != nullptr)
-        for (; md->name != nullptr; md++)
-            if (strcmp(md->name, name) == 0)
-                return 1;
-    // staticmethod has just a `__doc__` in the class
-    assert(strcmp(type->tp_name, "staticmethod") == 0 && strcmp(name, "__doc__") == 0);
+    // staticmethod has just a __doc__ in the class
+    assert(strcmp(type->tp_name, "staticmethod") == 0);
     return 0;
 }
 
 static int
-add_more_getsets(PyTypeObject *type, PyGetSetDef *gsp, PyObject **doc_descr)
+add_more_getsets(PyTypeObject *type, PyGetSetDef *gsp, PyObject **old_descr)
 {
     /*
-     * This function is used to assign a new `__signature__` attribute,
-     * and also to override a `__doc__` or `__name__` attribute.
+     * This function is used to assign a new __signature__ attribute,
+     * and also to override a __doc__ attribute.
      */
     assert(PyType_Check(type));
     PyType_Ready(type);
@@ -676,11 +671,9 @@ add_more_getsets(PyTypeObject *type, PyGetSetDef *gsp, PyObject **doc_descr)
     for (; gsp->name != nullptr; gsp++) {
         PyObject *have_descr = PyDict_GetItemString(dict, gsp->name);
         if (have_descr != nullptr) {
+            assert(strcmp(gsp->name, "__doc__") == 0);
             Py_INCREF(have_descr);
-            if (strcmp(gsp->name, "__doc__") == 0)
-                *doc_descr = have_descr;
-            else
-                assert(false);
+            *old_descr = have_descr;
             if (!_fixup_getset(type, gsp->name, gsp))
                 continue;
         }
@@ -831,7 +824,7 @@ static PyGetSetDef new_PyWrapperDescr_getsets[] = {
 //
 // Additionally to the interface via __signature__, we also provide
 // a general function, which allows for different signature layouts.
-// The "modifier" argument is a string that is passed in from 'loader.py'.
+// The "modifier" argument is a string that is passed in from loader.py .
 // Configuration what the modifiers mean is completely in Python.
 //
 
@@ -916,25 +909,13 @@ PySide_PatchTypes(void)
                                         reinterpret_cast<PyObject *>(&PyString_Type), "split"));
         Shiboken::AutoDecRef wrap_descr(PyObject_GetAttrString(
                                         reinterpret_cast<PyObject *>(Py_TYPE(Py_True)), "__add__"));
-        // abbreviations for readability
-        auto md_gs = new_PyMethodDescr_getsets;
-        auto md_doc = &old_md_doc_descr;
-        auto cf_gs = new_PyCFunction_getsets;
-        auto cf_doc = &old_cf_doc_descr;
-        auto sm_gs = new_PyStaticMethod_getsets;
-        auto sm_doc = &old_sm_doc_descr;
-        auto tp_gs = new_PyType_getsets;
-        auto tp_doc = &old_tp_doc_descr;
-        auto wd_gs = new_PyWrapperDescr_getsets;
-        auto wd_doc = &old_wd_doc_descr;
-
         if (meth_descr.isNull() || wrap_descr.isNull()
             || PyType_Ready(Py_TYPE(meth_descr)) < 0
-            || add_more_getsets(PepMethodDescr_TypePtr,  md_gs, md_doc) < 0
-            || add_more_getsets(&PyCFunction_Type,       cf_gs, cf_doc) < 0
-            || add_more_getsets(PepStaticMethod_TypePtr, sm_gs, sm_doc) < 0
-            || add_more_getsets(&PyType_Type,            tp_gs, tp_doc) < 0
-            || add_more_getsets(Py_TYPE(wrap_descr),     wd_gs, wd_doc) < 0
+            || add_more_getsets(PepMethodDescr_TypePtr,  new_PyMethodDescr_getsets,  &old_md_doc_descr) < 0
+            || add_more_getsets(&PyCFunction_Type,       new_PyCFunction_getsets,    &old_cf_doc_descr) < 0
+            || add_more_getsets(PepStaticMethod_TypePtr, new_PyStaticMethod_getsets, &old_sm_doc_descr) < 0
+            || add_more_getsets(&PyType_Type,            new_PyType_getsets,         &old_tp_doc_descr) < 0
+            || add_more_getsets(Py_TYPE(wrap_descr),     new_PyWrapperDescr_getsets, &old_wd_doc_descr) < 0
             )
             return -1;
 #ifndef _WIN32
@@ -1233,8 +1214,8 @@ FinishSignatureInitialization(PyObject *module, const char *signatures[])
      * Still, it is not possible to call init phase 2 from here,
      * because the import is still running. Do it from Python!
      */
-    if (   PySide_PatchTypes() < 0
-        || PySide_FinishSignatures(module, signatures) < 0) {
+    PySide_PatchTypes();
+    if (PySide_FinishSignatures(module, signatures) < 0) {
         PyErr_Print();
         PyErr_SetNone(PyExc_ImportError);
     }
@@ -1285,4 +1266,10 @@ PyObject *Sbk_TypeGet___doc__(PyObject *ob)
     return pyside_tp_get___doc__(ob);
 }
 
+PyObject *GetFeatureDict()
+{
+    init_module_1();
+    return pyside_globals->feature_dict;
+}
+
 } //extern "C"
diff --git a/sources/shiboken2/libshiboken/signature.h b/sources/shiboken2/libshiboken/signature.h
index b22a78497..2a69df9cf 100644
--- a/sources/shiboken2/libshiboken/signature.h
+++ b/sources/shiboken2/libshiboken/signature.h
@@ -50,6 +50,7 @@ LIBSHIBOKEN_API void FinishSignatureInitialization(PyObject *, const char *[]);
 LIBSHIBOKEN_API void SetError_Argument(PyObject *, const char *);
 LIBSHIBOKEN_API PyObject *Sbk_TypeGet___signature__(PyObject *, PyObject *);
 LIBSHIBOKEN_API PyObject *Sbk_TypeGet___doc__(PyObject *);
+LIBSHIBOKEN_API PyObject *GetFeatureDict();
 
 } // extern "C"
 
diff --git a/sources/shiboken2/shibokenmodule/CMakeLists.txt b/sources/shiboken2/shibokenmodule/CMakeLists.txt
index e1eafa12f..b14de5c9e 100644
--- a/sources/shiboken2/shibokenmodule/CMakeLists.txt
+++ b/sources/shiboken2/shibokenmodule/CMakeLists.txt
@@ -42,6 +42,8 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_config.py"
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/__init__.py.in"
                "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" @ONLY)
 
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/files.dir/shibokensupport/__feature__.py"
+               "${CMAKE_CURRENT_BINARY_DIR}/files.dir/shibokensupport/__feature__.py" COPYONLY)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/files.dir/shibokensupport/__init__.py"
                "${CMAKE_CURRENT_BINARY_DIR}/files.dir/shibokensupport/__init__.py" COPYONLY)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/files.dir/shibokensupport/signature/__init__.py"
diff --git a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/__feature__.py b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/__feature__.py
new file mode 100644
index 000000000..58c1ff925
--- /dev/null
+++ b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/__feature__.py
@@ -0,0 +1,111 @@
+#############################################################################
+##
+## Copyright (C) 2020 The Qt Company Ltd.
+## Contact: https://www.qt.io/licensing/
+##
+## This file is part of Qt for Python.
+##
+## $QT_BEGIN_LICENSE:LGPL$
+## Commercial License Usage
+## Licensees holding valid commercial Qt licenses may use this file in
+## accordance with the commercial license agreement provided with the
+## Software or, alternatively, in accordance with the terms contained in
+## a written agreement between you and The Qt Company. For licensing terms
+## and conditions see https://www.qt.io/terms-conditions. For further
+## information use the contact form at https://www.qt.io/contact-us.
+##
+## GNU Lesser General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU Lesser
+## General Public License version 3 as published by the Free Software
+## Foundation and appearing in the file LICENSE.LGPL3 included in the
+## packaging of this file. Please review the following information to
+## ensure the GNU Lesser General Public License version 3 requirements
+## will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+##
+## GNU General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU
+## General Public License version 2.0 or (at your option) the GNU General
+## Public license version 3 or any later version approved by the KDE Free
+## Qt Foundation. The licenses are as published by the Free Software
+## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+## included in the packaging of this file. Please review the following
+## information to ensure the GNU General Public License requirements will
+## be met: https://www.gnu.org/licenses/gpl-2.0.html and
+## https://www.gnu.org/licenses/gpl-3.0.html.
+##
+## $QT_END_LICENSE$
+##
+#############################################################################
+
+from __future__ import print_function, absolute_import
+
+"""
+__feature__.py
+
+This is the feature file for the Qt for Python project. There is some
+similarity to Python's `__future__` file, but also some distinction.
+"""
+
+import sys
+
+all_feature_names = [
+    "_dummy_feature_01",
+    "_dummy_feature_02",
+    "_dummy_feature_04",
+    "_dummy_feature_08",
+    "_dummy_feature_10",
+    "_dummy_feature_20",
+    "_dummy_feature_40",
+    "_dummy_feature_80",
+]
+
+__all__ = ["all_feature_names"] + all_feature_names
+
+_dummy_feature_01 = 0x01
+_dummy_feature_02 = 0x02
+_dummy_feature_04 = 0x04
+_dummy_feature_08 = 0x08
+_dummy_feature_10 = 0x10
+_dummy_feature_20 = 0x20
+_dummy_feature_40 = 0x40
+_dummy_feature_80 = 0x80
+
+# let's remove the dummies for the normal user
+_really_all_feature_names = all_feature_names[:]
+all_feature_names = list(_ for _ in all_feature_names if not _.startswith("_"))
+
+# Install an import hook that controls the `__feature__` import.
+"""
+Note: This are two imports.
+>>> import dis
+>>> def test():
+...     from __feature__ import snake_case
+...
+>>> dis.dis(test)
+  2           0 LOAD_CONST               1 (0)
+              2 LOAD_CONST               2 (('snake_case',))
+              4 IMPORT_NAME              0 (__feature__)
+              6 IMPORT_FROM              1 (snake_case)
+              8 STORE_FAST               0 (snake_case)
+             10 POP_TOP
+             12 LOAD_CONST               0 (None)
+             14 RETURN_VALUE
+"""
+# XXX build an improved C version
+def _import(name, *args, **kwargs):
+    if name == "__feature__" and args[2]:
+        # This is an `import from` statement that corresponds to `IMPORT_NAME`.
+        # The following `IMPORT_FROM` will handle errors. (Confusing, ofc.)
+        flag = 0
+        for feature in args[2]:
+            if feature in _really_all_feature_names:
+                flag |= globals()[feature]
+            else:
+                raise SyntaxError("PySide feature {} is not defined".format(feature))
+        importing_module = sys._getframe(1).f_globals['__name__']
+        existing = pyside_feature_dict.get(importing_module, 0)
+        if isinstance(existing, int):
+            flag |= existing & 255
+        pyside_feature_dict[importing_module] = flag
+        return sys.modules["__feature__"]
+    return original_import(name, *args, **kwargs)
diff --git a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/loader.py b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/loader.py
index 1efc6fde5..6cee54680 100644
--- a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/loader.py
+++ b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/loader.py
@@ -114,8 +114,10 @@ def finish_import(module):
 
 
 import signature_bootstrap
-from shibokensupport import signature
+from shibokensupport import signature, __feature__
 signature.get_signature = signature_bootstrap.get_signature
+# PYSIDE-1019: Publish the __feature__ dictionary.
+__feature__.pyside_feature_dict = signature_bootstrap.pyside_feature_dict
 del signature_bootstrap
 
 def _get_modname(mod):
@@ -194,6 +196,7 @@ def move_into_pyside_package():
         import PySide2.support
     except ModuleNotFoundError:
         PySide2.support = types.ModuleType("PySide2.support")
+    put_into_package(PySide2.support, __feature__)
     put_into_package(PySide2.support, signature)
     put_into_package(PySide2.support.signature, mapping)
     put_into_package(PySide2.support.signature, errorhandler)
@@ -217,5 +220,16 @@ from shibokensupport.signature.lib import enum_sig
 if "PySide2" in sys.modules:
     # We publish everything under "PySide2.support.signature", again.
     move_into_pyside_package()
+    # PYSIDE-1019: Modify `__import__` to be `__feature__` aware.
+    # __feature__ is already in sys.modules, so this is actually no import
+    try:
+        import PySide2.support.__feature__
+        sys.modules["__feature__"] = PySide2.support.__feature__
+        PySide2.support.__feature__.original_import = __builtins__["__import__"]
+        __builtins__["__import__"] = PySide2.support.__feature__._import
+        # Maybe we should optimize that and change `__import__` from C, instead?
+    except ModuleNotFoundError:
+        print("__feature__ could not be imported. "
+              "This is an unsolved PyInstaller problem.", file=sys.stderr)
 
 # end of file