Move with_generics and define_generics to ClassMixin

jedi/inference/gradual/base.py

@@ -151,7 +151,7 @@ class DefineGenericBaseClass(LazyValueWrapper):
         )
 
 
-class GenericClass(ClassMixin, DefineGenericBaseClass):
+class GenericClass(DefineGenericBaseClass, ClassMixin):
     """
     A class that is defined with generics, might be something simple like:
 

jedi/inference/gradual/typing.py

@@ -203,7 +203,7 @@ class _TypingClassMixin(ClassMixin):
         return ValueName(self, self._tree_name)
 
 
-class TypingClassWithGenerics(_TypingClassMixin, ProxyWithGenerics):
+class TypingClassWithGenerics(ProxyWithGenerics, _TypingClassMixin):
     def infer_type_vars(self, value_set):
         type_var_dict = {}
         annotation_generics = self.get_generics()
@@ -240,7 +240,7 @@ class TypingClassWithGenerics(_TypingClassMixin, ProxyWithGenerics):
         )
 
 
-class ProxyTypingClassValue(_TypingClassMixin, ProxyTypingValue):
+class ProxyTypingClassValue(ProxyTypingValue, _TypingClassMixin):
     index_class = TypingClassWithGenerics
 
 

jedi/inference/value/klass.py

@@ -271,6 +271,36 @@ class ClassMixin(object):
                         return True
         return False
 
+    def with_generics(self, generics_tuple):
+        from jedi.inference.gradual.base import GenericClass
+        return GenericClass(
+            self,
+            TupleGenericManager(generics_tuple)
+        )
+
+    def define_generics(self, type_var_dict):
+        from jedi.inference.gradual.base import GenericClass
+
+        def remap_type_vars():
+            """
+            The TypeVars in the resulting classes have sometimes different names
+            and we need to check for that, e.g. a signature can be:
+
+            def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
+
+            However, the iterator is defined as Iterator[_T_co], which means it has
+            a different type var name.
+            """
+            for type_var in self.list_type_vars():
+                yield type_var_dict.get(type_var.py__name__(), NO_VALUES)
+
+        if type_var_dict:
+            return ValueSet([GenericClass(
+                self,
+                TupleGenericManager(tuple(remap_type_vars()))
+            )])
+        return ValueSet({self})
+
 
 class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
     api_type = u'class'
@@ -331,36 +361,6 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
             for index_value in index_value_set
         )
 
-    def with_generics(self, generics_tuple):
-        from jedi.inference.gradual.base import GenericClass
-        return GenericClass(
-            self,
-            TupleGenericManager(generics_tuple)
-        )
-
-    def define_generics(self, type_var_dict):
-        from jedi.inference.gradual.base import GenericClass
-
-        def remap_type_vars():
-            """
-            The TypeVars in the resulting classes have sometimes different names
-            and we need to check for that, e.g. a signature can be:
-
-            def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
-
-            However, the iterator is defined as Iterator[_T_co], which means it has
-            a different type var name.
-            """
-            for type_var in self.list_type_vars():
-                yield type_var_dict.get(type_var.py__name__(), NO_VALUES)
-
-        if type_var_dict:
-            return ValueSet([GenericClass(
-                self,
-                TupleGenericManager(tuple(remap_type_vars()))
-            )])
-        return ValueSet({self})
-
     @plugin_manager.decorate()
     def get_metaclass_filters(self, metaclass, is_instance):
         debug.warning('Unprocessed metaclass %s', metaclass)