1 files changed, 48 insertions, 34 deletions

diff --git a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
index a5e3247b1..f11f3cf3d 100644
--- a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
+++ b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
@@ -52,11 +52,6 @@ by producing a lot of clarity.
 import sys
 from shibokensupport.signature import inspect
 from shibokensupport.signature import get_signature
-try:
-    from PySide2.QtCore import Qt
-    EnumType = type(Qt.Key)
-except ImportError:
-    EnumType = None
 
 
 class ExactEnumerator(object):
@@ -69,6 +64,14 @@ class ExactEnumerator(object):
     """
 
     def __init__(self, formatter, result_type=dict):
+        global EnumType
+        try:
+            # Lazy import
+            from PySide2.QtCore import Qt
+            EnumType = type(Qt.Key)
+        except ImportError:
+            EnumType = None
+
         self.fmt = formatter
         self.result_type = result_type
         self.fmt.level = 0
@@ -81,6 +84,7 @@ class ExactEnumerator(object):
 
     def module(self, mod_name):
         __import__(mod_name)
+        self.fmt.mod_name = mod_name
         with self.fmt.module(mod_name):
             module = sys.modules[mod_name]
             members = inspect.getmembers(module, inspect.isclass)
@@ -90,7 +94,7 @@ class ExactEnumerator(object):
             for class_name, klass in members:
                 ret.update(self.klass(class_name, klass))
             if isinstance(klass, EnumType):
-                self.enum(klass)
+                raise SystemError("implement enum instances at module level")
             for func_name, func in functions:
                 ret.update(self.function(func_name, func))
             return ret
@@ -106,26 +110,47 @@ class ExactEnumerator(object):
                 name = modname + "." + base.__name__
             bases_list.append(name)
         class_str = "{}({})".format(class_name, ", ".join(bases_list))
-        with self.fmt.klass(class_name, class_str):
-            ret = self.result_type()
-            # class_members = inspect.getmembers(klass)
-            # gives us also the inherited things.
-            class_members = sorted(list(klass.__dict__.items()))
-            subclasses = []
-            functions = []
-            for thing_name, thing in class_members:
-                if inspect.isclass(thing):
-                    subclass_name = ".".join((class_name, thing_name))
-                    subclasses.append((subclass_name, thing))
-                elif inspect.isroutine(thing):
-                    func_name = thing_name.split(".")[0]   # remove ".overload"
+        ret = self.result_type()
+        # class_members = inspect.getmembers(klass)
+        # gives us also the inherited things.
+        class_members = sorted(list(klass.__dict__.items()))
+        subclasses = []
+        functions = []
+        enums = []
+
+        for thing_name, thing in class_members:
+            if inspect.isclass(thing):
+                subclass_name = ".".join((class_name, thing_name))
+                subclasses.append((subclass_name, thing))
+            elif inspect.isroutine(thing):
+                func_name = thing_name.split(".")[0]   # remove ".overload"
+                signature = getattr(thing, "__signature__", None)
+                if signature is not None:
                     functions.append((func_name, thing))
+            elif type(type(thing)) is EnumType:
+                enums.append((thing_name, thing))
+        init_signature = getattr(klass, "__signature__", None)
+        enums.sort(key=lambda tup: tup[1])  # sort by enum value
+        self.fmt.have_body = bool(subclasses or functions or enums or init_signature)
+
+        with self.fmt.klass(class_name, class_str):
             self.fmt.level += 1
+            self.fmt.class_name = class_name
+            if hasattr(self.fmt, "enum"):
+                # this is an optional feature
+                for enum_name, value in enums:
+                    with self.fmt.enum(class_name, enum_name, int(value)):
+                        pass
             for subclass_name, subclass in subclasses:
+                if klass == subclass:
+                    # this is a side effect of the typing module for Python 2.7
+                    # via the "._gorg" property, which we can safely ignore.
+                    print("Warning: {class_name} points to itself via {subclass_name}, skipped!"
+                          .format(**locals()))
+                    continue
                 ret.update(self.klass(subclass_name, subclass))
-                if isinstance(subclass, EnumType):
-                    self.enum(subclass)
-            ret = self.function("__init__", klass)
+                self.fmt.class_name = class_name
+            ret.update(self.function("__init__", klass))
             for func_name, func in functions:
                 func_kind = get_signature(func, "__func_kind__")
                 modifier = func_kind if func_kind in (
@@ -137,24 +162,13 @@ class ExactEnumerator(object):
     def function(self, func_name, func, modifier=None):
         self.fmt.level += 1
         ret = self.result_type()
-        signature = getattr(func, '__signature__', None)
+        signature = func.__signature__
         if signature is not None:
             with self.fmt.function(func_name, signature, modifier) as key:
                 ret[key] = signature
         self.fmt.level -= 1
         return ret
 
-    def enum(self, subclass):
-        if not hasattr(self.fmt, "enum"):
-            # this is an optional feature
-            return
-        class_name = subclass.__name__
-        for enum_name, value in subclass.__dict__.items():
-            if type(type(value)) is EnumType:
-                with self.fmt.enum(class_name, enum_name, int(value)):
-                    pass
-        self._after_enum = True
-
 
 def stringify(signature):
     if isinstance(signature, list):