given_types -> generics

jedi/evaluate/context/klass.py

@@ -274,7 +274,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
         if type_var_dict:
             return AnnotatedSubClass(
                 self,
-                given_types=tuple(remap_type_vars())
+                generics=tuple(remap_type_vars())
             )
         return self
 

jedi/evaluate/gradual/annotation.py

@@ -277,7 +277,7 @@ def _infer_type_vars(annotation_context, context_set):
     elif isinstance(annotation_context, AnnotatedClass):
         name = annotation_context.py__name__()
         if name == 'Iterable':
-            given = annotation_context.get_given_types()
+            given = annotation_context.get_generics()
             if given:
                 for nested_annotation_context in given[0]:
                     _merge_type_var_dicts(
@@ -288,7 +288,7 @@ def _infer_type_vars(annotation_context, context_set):
                         )
                     )
         elif name == 'Mapping':
-            given = annotation_context.get_given_types()
+            given = annotation_context.get_generics()
             if len(given) == 2:
                 for context in context_set:
                     try:

jedi/evaluate/gradual/typing.py

@@ -492,15 +492,15 @@ class TypeVarFilter(object):
 
     In this example we would have two type vars given: A and B
     """
-    def __init__(self, given_types, type_vars):
-        self._given_types = given_types
+    def __init__(self, generics, type_vars):
+        self._generics = generics
         self._type_vars = type_vars
 
     def get(self, name):
         for i, type_var in enumerate(self._type_vars):
             if type_var.py__name__() == name:
                 try:
-                    return [BoundTypeVarName(type_var, self._given_types[i])]
+                    return [BoundTypeVarName(type_var, self._generics[i])]
                 except IndexError:
                     return [type_var.name]
         return []
@@ -513,7 +513,7 @@ class TypeVarFilter(object):
 
 class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
     def get_type_var_filter(self):
-        return TypeVarFilter(self.get_given_types(), self.list_type_vars())
+        return TypeVarFilter(self.get_generics(), self.list_type_vars())
 
     def get_filters(self, search_global=False, *args, **kwargs):
         filters = super(AbstractAnnotatedClass, self).get_filters(
@@ -535,8 +535,8 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
         if self.tree_node != other.tree_node:
             # TODO not sure if this is nice.
             return False
-        given_params1 = self.get_given_types()
-        given_params2 = other.get_given_types()
+        given_params1 = self.get_generics()
+        given_params2 = other.get_generics()
 
         if len(given_params1) != len(given_params2):
             # If the amount of type vars doesn't match, the class doesn't
@@ -557,13 +557,13 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
         instance, = super(AbstractAnnotatedClass, self).py__call__(arguments)
         return ContextSet([InstanceWrapper(instance)])
 
-    def get_given_types(self):
+    def get_generics(self):
         raise NotImplementedError
 
     def define_generics(self, type_var_dict):
         changed = False
         new_generics = []
-        for generic_set in self.get_given_types():
+        for generic_set in self.get_generics():
             contexts = NO_CONTEXTS
             for generic in generic_set:
                 if isinstance(generic, AbstractAnnotatedClass):
@@ -590,14 +590,14 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
 
         return AnnotatedSubClass(
             self._wrapped_context,
-            given_types=tuple(new_generics)
+            generics=tuple(new_generics)
         )
 
     def __repr__(self):
         return '<%s: %s%s>' % (
             self.__class__.__name__,
             self._wrapped_context,
-            list(self.get_given_types()),
+            list(self.get_generics()),
         )
 
     @to_list
@@ -613,7 +613,7 @@ class AnnotatedClass(AbstractAnnotatedClass):
         self._context_of_index = context_of_index
 
     @evaluator_method_cache()
-    def get_given_types(self):
+    def get_generics(self):
         return list(_iter_over_arguments(self._index_context, self._context_of_index))
 
     def annotate_other_class(self, cls):
@@ -621,12 +621,12 @@ class AnnotatedClass(AbstractAnnotatedClass):
 
 
 class AnnotatedSubClass(AbstractAnnotatedClass):
-    def __init__(self, class_context, given_types):
+    def __init__(self, class_context, generics):
         super(AnnotatedSubClass, self).__init__(class_context)
-        self._given_types = given_types
+        self._generics = generics
 
-    def get_given_types(self):
-        return self._given_types
+    def get_generics(self):
+        return self._generics
 
 
 class LazyAnnotatedBaseClass(object):
@@ -649,7 +649,7 @@ class LazyAnnotatedBaseClass(object):
 
     def _remap_type_vars(self, base):
         filter = self._class_context.get_type_var_filter()
-        for type_var_set in base.get_given_types():
+        for type_var_set in base.get_generics():
             new = NO_CONTEXTS
             for type_var in type_var_set:
                 if isinstance(type_var, TypeVar):
@@ -669,9 +669,9 @@ class InstanceWrapper(ContextWrapper):
     def py__stop_iteration_returns(self):
         for cls in self._wrapped_context.class_context.py__mro__():
             if cls.py__name__() == 'Generator':
-                given_types = cls.get_given_types()
+                generics = cls.get_generics()
                 try:
-                    return given_types[2].execute_annotation()
+                    return generics[2].execute_annotation()
                 except IndexError:
                     pass
             elif cls.py__name__() == 'Iterator':