Rename AnnotatedClass to GenericClass

jedi/evaluate/gradual/annotation.py

@@ -12,7 +12,7 @@ from parso import ParserSyntaxError, parse
 from jedi._compatibility import force_unicode
 from jedi.evaluate.cache import evaluator_method_cache
 from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.typing import TypeVar, AnnotatedClass, \
+from jedi.evaluate.gradual.typing import TypeVar, LazyGenericClass, \
     AbstractAnnotatedClass
 from jedi.evaluate.helpers import is_string
 from jedi import debug
@@ -274,7 +274,7 @@ def _infer_type_vars(annotation_context, context_set):
     type_var_dict = {}
     if isinstance(annotation_context, TypeVar):
         return {annotation_context.py__name__(): context_set.py__class__()}
-    elif isinstance(annotation_context, AnnotatedClass):
+    elif isinstance(annotation_context, LazyGenericClass):
         name = annotation_context.py__name__()
         if name == 'Iterable':
             given = annotation_context.get_generics()

jedi/evaluate/gradual/typing.py

@@ -588,7 +588,7 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
             # cached results.
             return self
 
-        return AnnotatedSubClass(
+        return GenericClass(
             self._wrapped_context,
             generics=tuple(new_generics)
         )
@@ -606,9 +606,9 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
             yield LazyAnnotatedBaseClass(self, base)
 
 
-class AnnotatedClass(AbstractAnnotatedClass):
+class LazyGenericClass(AbstractAnnotatedClass):
     def __init__(self, class_context, index_context, context_of_index):
-        super(AnnotatedClass, self).__init__(class_context)
+        super(LazyGenericClass, self).__init__(class_context)
         self._index_context = index_context
         self._context_of_index = context_of_index
 
@@ -617,9 +617,9 @@ class AnnotatedClass(AbstractAnnotatedClass):
         return list(_iter_over_arguments(self._index_context, self._context_of_index))
 
 
-class AnnotatedSubClass(AbstractAnnotatedClass):
+class GenericClass(AbstractAnnotatedClass):
     def __init__(self, class_context, generics):
-        super(AnnotatedSubClass, self).__init__(class_context)
+        super(GenericClass, self).__init__(class_context)
         self._generics = generics
 
     def get_generics(self):
@@ -636,7 +636,7 @@ class LazyAnnotatedBaseClass(object):
         for base in self._lazy_base_class.infer():
             if isinstance(base, AbstractAnnotatedClass):
                 # Here we have to recalculate the given types.
-                yield AnnotatedSubClass.create_cached(
+                yield GenericClass.create_cached(
                     base.evaluator,
                     base._wrapped_context,
                     tuple(self._remap_type_vars(base)),