Merge remote-tracking branch 'origin/5.6' into 5.9

Change-Id: I78039827d32c1d4d540a8b1b2afd4841e40d5c2c

9 files changed, 262 insertions, 155 deletions

diff --git a/sources/pyside2/PySide2/support/signature/mapping.py b/sources/pyside2/PySide2/support/signature/mapping.py
index 50ae27718..367e1c04d 100644
--- a/sources/pyside2/PySide2/support/signature/mapping.py
+++ b/sources/pyside2/PySide2/support/signature/mapping.py
@@ -63,7 +63,7 @@ StringList = typing.List[str]
 IntList = typing.List[int]
 Variant = typing.Any
 ModelIndexList = typing.List[int]
-QImageCleanupFunction = typing.Callable[[bytes], None]
+QImageCleanupFunction = typing.Callable
 FloatMatrix = typing.List[typing.List[float]]
 # Pair could be more specific, but we loose the info in the generator.
 Pair = typing.Tuple[typing.Any, typing.Any]
diff --git a/sources/pyside2/doc/inheritance_diagram.py b/sources/pyside2/doc/inheritance_diagram.py
index 616b47057..a7f376ccd 100644
--- a/sources/pyside2/doc/inheritance_diagram.py
+++ b/sources/pyside2/doc/inheritance_diagram.py
@@ -295,7 +295,7 @@ class InheritanceDiagram(Directive):
             graph = InheritanceGraph(
                 class_names, env.temp_data.get('py:module'),
                 parts=node['parts'])
-        except InheritanceException, err:
+        except InheritanceException as err:
             return [node.document.reporter.warning(err.args[0],
                                                    line=self.lineno)]
 
diff --git a/sources/pyside2/libpyside/signalmanager.cpp.in b/sources/pyside2/libpyside/signalmanager.cpp.in
index 8ede09610..08c57c218 100644
--- a/sources/pyside2/libpyside/signalmanager.cpp.in
+++ b/sources/pyside2/libpyside/signalmanager.cpp.in
@@ -471,24 +471,14 @@ int SignalManager::qt_metacall(QObject* object, QMetaObject::Call call, int id,
 
             if (data && !data->jsWrapper.isNullOrUndefined()) {
                 QV4::ExecutionEngine *engine = data->jsWrapper.engine();
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
-                QV4::Heap::ExecutionContext *ctx = engine->current;
-#elif QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
-                QV4::Heap::ExecutionContext *ctx = engine->currentContext();
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+                if (engine->currentStackFrame != nullptr) {
+#elif QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
+                if (engine->currentContext->d() != engine->rootContext()->d()) {
 #else
                 QV4::ExecutionContext *ctx = engine->currentContext();
-#endif
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
                 if (ctx->type == QV4::Heap::ExecutionContext::Type_CallContext ||
                     ctx->type == QV4::Heap::ExecutionContext::Type_SimpleCallContext) {
-#elif QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
-                if (ctx->d()->type == QV4::ExecutionContext::Type_CallContext ||
-                    ctx->d()->type == QV4::ExecutionContext::Type_SimpleCallContext) {
-#else
-                if (ctx->type == QV4::ExecutionContext::Type_CallContext ||
-                    ctx->type == QV4::ExecutionContext::Type_SimpleCallContext) {
 #endif
                     PyObject *errType, *errValue, *errTraceback;
                     PyErr_Fetch(&errType, &errValue, &errTraceback);
diff --git a/sources/pyside2/tests/QtCore/bug_829.py b/sources/pyside2/tests/QtCore/bug_829.py
index 5b14f7b59..730a2e9ed 100644
--- a/sources/pyside2/tests/QtCore/bug_829.py
+++ b/sources/pyside2/tests/QtCore/bug_829.py
@@ -30,21 +30,36 @@
 # Test case for PySide bug 829
 
 import unittest
-from PySide2.QtCore import QSettings
-import tempfile
+from PySide2.QtCore import QDir, QSettings, QTemporaryFile
+import os
 
 class QVariantConversions(unittest.TestCase):
+
+    _confFileName = None
+
     def testDictionary(self):
-        confFile = tempfile.NamedTemporaryFile(delete=False)
-        s = QSettings(confFile.name, QSettings.IniFormat)
+        confFile = QTemporaryFile(QDir.tempPath() + '/pysidebug829_XXXXXX.ini')
+        confFile.setAutoRemove(False)
+        self.assertTrue(confFile.open())
+        confFile.close()
+        self._confFileName = confFile.fileName()
+        del confFile
+        s = QSettings(self._confFileName, QSettings.IniFormat)
+        self.assertEqual(s.status(), QSettings.NoError)
         # Save value
         s.setValue('x', {1: 'a'})
         s.sync()
+        self.assertEqual(s.status(), QSettings.NoError)
         del s
 
         # Restore value
-        s = QSettings(confFile.name, QSettings.IniFormat)
+        s = QSettings(self._confFileName, QSettings.IniFormat)
+        self.assertEqual(s.status(), QSettings.NoError)
         self.assertEqual(s.value('x'), {1: 'a'})
 
+    def __del__(self):
+        if self._confFileName is not None:
+            os.unlink(QDir.toNativeSeparators(self._confFileName))
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/registry/existence_test.py b/sources/pyside2/tests/registry/existence_test.py
index 7627eeab2..8f3c568a3 100644
--- a/sources/pyside2/tests/registry/existence_test.py
+++ b/sources/pyside2/tests/registry/existence_test.py
@@ -42,27 +42,46 @@ from __future__ import print_function, absolute_import
 import os
 import sys
 import unittest
-import warnings
-from init_platform import enum_all, generate_all, is_ci, outname, outpath
-from util import isolate_warnings, check_warnings
+from textwrap import dedent
+from init_platform import (enum_all, generate_all, is_ci,
+   getEffectiveRefPath, getRefPath, qtVersion)
+from util import isolate_warnings, check_warnings, suppress_warnings, warn
 from PySide2 import *
-from PySide2.QtCore import __version__
 
-refmodule_name = outname[:-3] # no .py
-pyc = os.path.splitext(outpath)[0] + ".pyc"
-if os.path.exists(pyc) and not os.path.exists(outname):
+refPath = getRefPath()
+effectiveRefPath = getEffectiveRefPath()
+effectiveRefPathRoot = os.path.splitext(effectiveRefPath)[0]
+pyc = effectiveRefPathRoot + ".pyc"
+if os.path.exists(pyc) and not os.path.exists(effectiveRefPath):
     # on Python2 the pyc file would be imported
     os.unlink(pyc)
+module = os.path.basename(effectiveRefPathRoot)
 
-sys.path.insert(0, os.path.dirname(__file__))
+if refPath != effectiveRefPath:
+    print("*** Falling back to ", effectiveRefPath, " since expected ",
+        refPath, " does not exist")
+
+home_dir = effectiveRefPath
+for _ in "abcde":
+    home_dir = os.path.dirname(home_dir)
+shortpath = os.path.relpath(effectiveRefPath, home_dir)
 try:
-    exec("import {} as sig_exists".format(refmodule_name))
-    print("found:", refmodule_name)
+    exec("import {} as sig_exists".format(module))
+    print("found:", shortpath)
     have_refmodule = True
 except ImportError:
-    print("*** not found:", refmodule_name)
+    print("*** not found:", shortpath)
+    have_refmodule = False
+except SyntaxError:
+    print("*** not a python file, removed:", shortpath)
+    os.unlink(effectiveRefPath)
+    have_refmodule = False
+if have_refmodule and not hasattr(sig_exists, "dict"):
+    print("*** wrong module without 'dict', removed:", shortpath)
+    os.unlink(effectiveRefPath)
     have_refmodule = False
 
+
 @unittest.skipIf(not have_refmodule,
                  "not activated for this platform or version")
 class TestSignaturesExists(unittest.TestCase):
@@ -76,10 +95,13 @@ class TestSignaturesExists(unittest.TestCase):
         found_sigs = enum_all()
         with isolate_warnings():
             for key, value in sig_exists.dict.items():
+                name = key.rsplit(".", 1)[-1]
+                if name in ("next", "__next__"): # ignore problematic cases
+                    continue
                 if key not in found_sigs:
-                    warnings.warn("missing key: '{}'".format(key), RuntimeWarning)
+                    warn("missing key: '{}'".format(key))
                 elif isinstance(value, list) and len(value) != len(found_sigs[key]):
-                    warnings.warn("different sig length: '{}'".format(key), RuntimeWarning)
+                    warn("multi-signature count mismatch: '{}'".format(key))
             if is_ci and check_warnings():
                 raise RuntimeError("There are errors, see above.")
 
@@ -87,18 +109,20 @@ class TestSignaturesExists(unittest.TestCase):
         found_sigs = enum_all()
         # make sure that errors are actually raised
         found_sigs.pop(list(found_sigs.keys())[42])
-        with isolate_warnings():
+        with isolate_warnings(), suppress_warnings():
             for key, value in sig_exists.dict.items():
+                name = key.rsplit(".", 1)[-1]
+                if name in ("next", "__next__"): # ignore problematic cases
+                    continue
                 if key not in found_sigs:
-                    warnings.warn("ignore missing key: '{}'".format(key), RuntimeWarning)
+                    warn("missing key: '{}'".format(key))
                 elif isinstance(value, list) and len(value) != len(found_sigs[key]):
-                    warnings.warn("ignore different sig length: '{}'".format(key), RuntimeWarning)
+                    warn("multi-signature count mismatch: '{}'".format(key))
             self.assertTrue(check_warnings())
 
-version = tuple(map(int, __version__.split(".")))
 tested_versions = (5, 6), (5, 9), (5, 11)
 
-if not have_refmodule and is_ci and version[:2] in tested_versions:
+if not have_refmodule and is_ci and qtVersion()[:2] in tested_versions:
     class TestFor_CI_Init(unittest.TestCase):
         """
         This helper class generates the reference file for CI.
@@ -107,12 +131,16 @@ if not have_refmodule and is_ci and version[:2] in tested_versions:
         """
         generate_all()
         sys.stderr.flush()
-        print("BEGIN", outpath, file=sys.stderr)
-        with open(outpath) as f:
+        print("BEGIN_FILE", refPath, file=sys.stderr)
+        with open(refPath) as f:
             print(f.read(), file=sys.stderr)
-        print("END", outpath, file=sys.stderr)
+        print("END_FILE", refPath, file=sys.stderr)
         sys.stderr.flush()
-        raise RuntimeError("This is the initial call. You should check this file in.")
+        raise RuntimeError(dedent("""
+            {line}
+            **  This is the initial call. You should check this file in:
+            **  {}
+            **""").format(refPath, line=79 * "*"))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/registry/init_platform.py b/sources/pyside2/tests/registry/init_platform.py
index ea8eb2af2..ffe6e22fc 100644
--- a/sources/pyside2/tests/registry/init_platform.py
+++ b/sources/pyside2/tests/registry/init_platform.py
@@ -49,35 +49,140 @@ One file is generated with all signatures of a platform and version.
 import sys
 import os
 import PySide2
+from contextlib import contextmanager
+from textwrap import dedent
 
 all_modules = list("PySide2." + x for x in PySide2.__all__)
 
 from PySide2.support.signature import inspect
 from PySide2.QtCore import __version__
 
-version_id = __version__.replace(".", "_")
+is_py3 = sys.version_info[0] == 3
 is_ci = os.environ.get("QTEST_ENVIRONMENT", "") == "ci"
 # Python2 legacy: Correct 'linux2' to 'linux', recommended way.
 platform = 'linux' if sys.platform.startswith('linux') else sys.platform
-outname = "exists_{}_{}{}.py".format(platform, version_id,
-                                     "_ci" if is_ci else "")
-outpath = os.path.join(os.path.dirname(__file__), outname)
-outfile = None
+# Make sure not to get .pyc in Python2.
+sourcepath = os.path.splitext(__file__)[0] + ".py"
+
+def qtVersion():
+    return tuple(map(int, __version__.split(".")))
+
+# Format a registry file name for version
+def _registryFileName(version):
+    name = "exists_{}_{}_{}_{}{}.py".format(platform,
+        version[0], version[1], version[2], "_ci" if is_ci else "")
+    return os.path.join(os.path.dirname(__file__), name)
+
+# Return the expected registry file name
+def getRefPath():
+    return _registryFileName(qtVersion())
+
+# Return the registry file name, either that of the current
+# version or fall back to a previous patch release
+def getEffectiveRefPath():
+    refpath = getRefPath()
+    if os.path.exists(refpath):
+        return refpath
+    version = qtVersion()
+    majorVersion = version[0]
+    minorVersion = version[1]
+    patchVersion = version[2]
+    while patchVersion >= 0:
+        file = _registryFileName((majorVersion, minorVersion, patchVersion))
+        if os.path.exists(file):
+            return file
+        patchVersion = patchVersion - 1
+    return refpath
+
+class Formatter(object):
+    """
+    Formatter is formatting the signature listing of an enumerator.
+
+    It is written as context managers in order to avoid many callbacks.
+    The division in formatter and enumerator is done to keep the
+    unrelated tasks of enumeration and formatting apart.
+    """
+    def __init__(self, outfile):
+        self.outfile = outfile
+
+    def print(self, *args, **kw):
+        print(*args, file=self.outfile, **kw) if self.outfile else None
+
+    @contextmanager
+    def module(self, mod_name):
+        self.mod_name = mod_name
+        self.print("")
+        self.print("# Module", mod_name)
+        self.print('if "{}" in sys.modules:'.format(mod_name))
+        self.print("    dict.update({")
+        yield
+        self.print("    })")
+
+    @contextmanager
+    def klass(self, class_name):
+        self.class_name = class_name
+        self.print()
+        self.print("    # class {}.{}:".format(self.mod_name, class_name))
+        yield
+
+    @contextmanager
+    def function(self, func_name, signature):
+        key = viskey = "{}.{}".format(self.class_name, func_name)
+        if key.endswith("lY"):
+            # Some classes like PySide2.QtGui.QContextMenuEvent have functions
+            # globalX and the same with Y. The gerrit robot thinks that this
+            # is a badly written "globally". Convince it by hiding this word.
+            viskey = viskey[:-1] + '""Y'
+        self.print('        "{}": {},'.format(viskey, signature))
+        yield key
+
+
+class ExactEnumerator(object):
+    """
+    ExactEnumerator enumerates all signatures in a module as they are.
+
+    This class is used for generating complete listings of all signatures.
+    An appropriate formatter should be supplied, if printable output
+    is desired.
+    """
+    def __init__(self, formatter, result_type=dict):
+        self.fmt = formatter
+        self.result_type = result_type
+
+    def module(self, mod_name):
+        __import__(mod_name)
+        with self.fmt.module(mod_name):
+            module = sys.modules[mod_name]
+            members = inspect.getmembers(module, inspect.isclass)
+            ret = self.result_type()
+            for class_name, klass in members:
+                ret.update(self.klass(class_name, klass))
+            return ret
+
+    def klass(self, class_name, klass):
+        with self.fmt.klass(class_name):
+            ret = self.function("__init__", klass)
+            # class_members = inspect.getmembers(klass)
+            # gives us also the inherited things.
+            class_members = sorted(list(klass.__dict__.items()))
+            for func_name, func in class_members:
+                ret.update(self.function(func_name, func))
+            return ret
+
+    def function(self, func_name, func):
+        ret = self.result_type()
+        signature = getattr(func, '__signature__', None)
+        if signature is not None:
+            with self.fmt.function(func_name, signature) as key:
+                ret[key] = signature
+        return ret
 
-def xprint(*args, **kw):
-    if outfile:
-        print(*args, file=outfile, **kw)
 
 def simplify(signature):
     if isinstance(signature, list):
-        ret = list(simplify(sig) for sig in signature)
         # remove duplicates which still sometimes occour:
-        things = set(ret)
-        if len(things) != len(ret):
-            ret = list(things)
-            if len(ret) == 1:
-                ret = ret[0]
-        return sorted(ret)
+        ret = set(simplify(sig) for sig in signature)
+        return sorted(ret) if len(ret) > 1 else list(ret)[0]
     ret = []
     for pv in signature.parameters.values():
         txt = str(pv)
@@ -92,108 +197,64 @@ def simplify(signature):
         ret.append(txt)
     return tuple(ret)
 
-def begin_module(mod_name):
-    xprint("")
-    xprint("# Module", mod_name)
-    xprint('if "{}" in sys.modules:'.format(mod_name))
-    xprint("    dict.update({")
-
-def end_module(mod_name):
-    xprint("    })")
-
-def begin_class(mod_name, class_name):
-    xprint()
-    xprint("    # class {}.{}:".format(mod_name, class_name))
-
-def end_class(mod_name, class_name):
-    pass
-
-def show_signature(key, signature):
-    if key.endswith("lY"):
-        # make the robot shut up:
-        key = key[:-1] + '"+"Y'
-    xprint('        "{}": {},'.format(key, signature))
-
-def enum_module(mod_name):
-    __import__(mod_name)
-    begin_module(mod_name)
-    module = sys.modules[mod_name]
-    members = inspect.getmembers(module, inspect.isclass)
-    ret = {}
-    for class_name, klass in members:
-        begin_class(mod_name, class_name)
-        signature = getattr(klass, '__signature__', None)
-        # class_members = inspect.getmembers(klass)
-        # gives us also the inherited things.
-        if signature is not None:
-            signature = simplify(signature)
-            key = "{}.{}".format(class_name, "__init__")
-            ret[key] = signature
-            show_signature(key, signature)
-        class_members = sorted(list(klass.__dict__.items()))
-        for func_name, func in class_members:
-            signature = getattr(func, '__signature__', None)
-            if signature is not None:
-                signature = simplify(signature)
-                key = "{}.{}".format(class_name, func_name)
-                ret[key] = signature
-                show_signature(key, signature)
-        end_class(mod_name, class_name)
-    end_module(mod_name)
-    return ret
 
-def generate_all():
-    global outfile
-    with open(outpath, "w") as outfile:
-        with open(__file__) as f:
-            lines = f.readlines()
-        license_line = next((lno for lno, line in enumerate(lines)
-                             if "$QT_END_LICENSE$" in line))
-        xprint("".join(lines[:license_line + 3]))
-        xprint("import sys")
-        xprint("")
-        xprint("dict = {}")
-        for mod_name in all_modules:
-            enum_module(mod_name)
-        xprint("# eof")
+class SimplifyingEnumerator(ExactEnumerator):
+    """
+    SimplifyingEnumerator enumerates all signatures in a module filtered.
+
+    There are no default values, no variable
+    names and no self parameter. Only types are present after simplification.
+    The functions 'next' resp. '__next__' are removed
+    to make the output identical for Python 2 and 3.
+    An appropriate formatter should be supplied, if printable output
+    is desired.
+    """
+
+    def function(self, func_name, func):
+        ret = self.result_type()
+        signature = getattr(func, '__signature__', None)
+        sig = simplify(signature) if signature is not None else None
+        if sig is not None and func_name not in ("next", "__next__"):
+            with self.fmt.function(func_name, sig) as key:
+                ret[key] = sig
+        return ret
+
 
 def enum_all():
-    global outfile
-    outfile = None
-    ret = {}
+    fmt = Formatter(None)
+    enu = SimplifyingEnumerator(fmt)
+    ret = enu.result_type()
     for mod_name in all_modules:
-        ret.update(enum_module(mod_name))
+        ret.update(enu.module(mod_name))
     return ret
 
-# This function exists because I forgot to sort the files in the first place.
-def sort_dict(fname):
-    with open(fname) as f:
+def generate_all():
+    with open(refPath(), "w") as outfile, open(sourcepath) as f:
+        fmt = Formatter(outfile)
+        enu = SimplifyingEnumerator(fmt)
         lines = f.readlines()
-    out = []
-    while lines:
-        line = lines.pop(0)
-        if not line.lstrip().startswith('"'):
-            out.append(line)
-            continue
-        out.append(line)
-        buf = [] # leave __init__ in place
-        line = lines.pop(0)
-        while line.lstrip().startswith('"'):
-            buf.append(line)
-            line = lines.pop(0)
-        buf.sort()
-        out.extend(buf)
-        out.append(line)
-    with open(fname, "w") as f:
-        f.writelines(out)
+        license_line = next((lno for lno, line in enumerate(lines)
+                             if "$QT_END_LICENSE$" in line))
+        fmt.print("".join(lines[:license_line + 3]))
+        fmt.print(dedent('''\
+            """
+            This file contains the simplified signatures for all functions in PySide
+            for module '{}'. There are no default values, no variable
+            names and no self parameter. Only types are present after simplification.
+            The functions 'next' resp. '__next__' are removed
+            to make the output identical for Python 2 and 3.
+            """
+            '''.format(module)))
+        fmt.print("import sys")
+        fmt.print("")
+        fmt.print("dict = {}")
+        for mod_name in all_modules:
+            enu.module(mod_name)
+        fmt.print("# eof")
 
 def __main__():
-    if sys.argv[1:]:
-        fname = sys.argv[1]
-        print("we are just sorting", fname)
-        sort_dict(fname)
-        sys.exit(0)
-    print("+++ generating {}. You should check this file in.".format(outname))
+    print("+++ generating {}. You should probably check this file in."
+          .format(refpath))
     generate_all()
 
 if __name__ == "__main__":
diff --git a/sources/pyside2/tests/registry/signature_test.py b/sources/pyside2/tests/registry/signature_test.py
index 949244dc3..105f46e15 100644
--- a/sources/pyside2/tests/registry/signature_test.py
+++ b/sources/pyside2/tests/registry/signature_test.py
@@ -85,9 +85,9 @@ def enum_module(mod_name):
         else:
             dprint("    def __init__" + str(signature))
         count += 1
-        class_members = list(klass.__dict__.items())
         have_sig = signature is not None
         have_members = 0
+        class_members = sorted(list(klass.__dict__.items()))
         for func_name, func in class_members:
             signature = getattr(func, '__signature__', None)
             if signature is not None:
@@ -110,8 +110,9 @@ def enum_all():
     for mod_name in all_modules:
         result[mod_name] = enum_module(mod_name)
         total += result[mod_name]
-    pprint(result if sys.version_info >= (3,) else list(result.items()))
-    print("Total", total)
+    pprint(result if sys.version_info >= (3,) else list(result.items()),
+           stream=sys.stderr)
+    print("Total", total, file=sys.stderr)
     return result
 
 
diff --git a/sources/pyside2/tests/registry/util.py b/sources/pyside2/tests/registry/util.py
index 5d0602b2a..7e048cb24 100644
--- a/sources/pyside2/tests/registry/util.py
+++ b/sources/pyside2/tests/registry/util.py
@@ -72,6 +72,12 @@ def isolate_warnings():
             if warn is None:
                 delattr(mod, warn_name)
 
+@contextmanager
+def suppress_warnings():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        yield
+
 def check_warnings():
     for name, mod in sys.modules.items():
         if mod:
@@ -85,4 +91,10 @@ def check_warnings():
                     return True
     return False
 
+def warn(message, category=None, stacklevel=1):
+    """Issue a warning with the default 'RuntimeWarning'"""
+    if category is None:
+        category = UserWarning
+    warnings.warn(message, category, stacklevel)
+
 # eof
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index 0a07964a5..e9d801044 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -456,7 +456,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
 
     if (metaClass->typeEntry()->isValue() || metaClass->typeEntry()->isSmartPointer()) {
         writeCopyFunction(s, classContext);
-        signatureStream << INDENT << metaClass->fullName() << ".__copy__()" << endl;
+        signatureStream << metaClass->fullName() << ".__copy__()" << endl;
     }
 
     // Write single method definitions