From 1002acf907e83d169f3ae269fcc565a60826070c Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Mon, 27 May 2019 21:21:42 +0200 Subject: [PATCH] Rename AnnotatedClass to GenericClass --- jedi/evaluate/context/function.py | 6 +++--- jedi/evaluate/context/iterable.py | 4 ++-- jedi/evaluate/context/klass.py | 8 ++++---- jedi/evaluate/gradual/annotation.py | 4 ++-- jedi/evaluate/gradual/typing.py | 12 ++++++------ 5 files changed, 17 insertions(+), 17 deletions(-) diff --git a/jedi/evaluate/context/function.py b/jedi/evaluate/context/function.py index a6f82cf9..f4a46ec5 100644 --- a/jedi/evaluate/context/function.py +++ b/jedi/evaluate/context/function.py @@ -333,7 +333,7 @@ class FunctionExecutionContext(TreeContext): evaluator = self.evaluator is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef') is_generator = bool(get_yield_exprs(evaluator, self.tree_node)) - from jedi.evaluate.gradual.typing import AnnotatedSubClass + from jedi.evaluate.gradual.typing import GenericClass if is_coroutine: if is_generator: @@ -347,7 +347,7 @@ class FunctionExecutionContext(TreeContext): generics = (yield_contexts.py__class__(), NO_CONTEXTS) return ContextSet( # In Python 3.6 AsyncGenerator is still a class. - AnnotatedSubClass(c, generics) + GenericClass(c, generics) for c in async_generator_classes ).execute_annotation() else: @@ -358,7 +358,7 @@ class FunctionExecutionContext(TreeContext): # Only the first generic is relevant. generics = (return_contexts.py__class__(), NO_CONTEXTS, NO_CONTEXTS) return ContextSet( - AnnotatedSubClass(c, generics) for c in async_classes + GenericClass(c, generics) for c in async_classes ).execute_annotation() else: if is_generator: diff --git a/jedi/evaluate/context/iterable.py b/jedi/evaluate/context/iterable.py index 81dac51d..e81dad15 100644 --- a/jedi/evaluate/context/iterable.py +++ b/jedi/evaluate/context/iterable.py @@ -208,10 +208,10 @@ class Sequence(BuiltinOverwrite, IterableMixin): @memoize_method def get_object(self): - from jedi.evaluate.gradual.typing import AnnotatedSubClass + from jedi.evaluate.gradual.typing import GenericClass klass = compiled.builtin_from_name(self.evaluator, self.array_type) # TODO is this execute annotation wrong? it returns a context set?! - return AnnotatedSubClass(klass, self._get_generics()).execute_annotation() + return GenericClass(klass, self._get_generics()).execute_annotation() def py__bool__(self): return None # We don't know the length, because of appends. diff --git a/jedi/evaluate/context/klass.py b/jedi/evaluate/context/klass.py index 2098786e..d90b9765 100644 --- a/jedi/evaluate/context/klass.py +++ b/jedi/evaluate/context/klass.py @@ -243,11 +243,11 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa )] def py__getitem__(self, index_context_set, contextualized_node): - from jedi.evaluate.gradual.typing import AnnotatedClass + from jedi.evaluate.gradual.typing import LazyGenericClass if not index_context_set: return ContextSet([self]) return ContextSet( - AnnotatedClass( + LazyGenericClass( self, index_context, context_of_index=contextualized_node.context, @@ -256,7 +256,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa ) def define_generics(self, type_var_dict): - from jedi.evaluate.gradual.typing import AnnotatedSubClass + from jedi.evaluate.gradual.typing import GenericClass def remap_type_vars(): """ @@ -272,7 +272,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa yield type_var_dict.get(type_var.py__name__(), NO_CONTEXTS) if type_var_dict: - return AnnotatedSubClass( + return GenericClass( self, generics=tuple(remap_type_vars()) ) diff --git a/jedi/evaluate/gradual/annotation.py b/jedi/evaluate/gradual/annotation.py index 1fcca31d..a2b9d251 100644 --- a/jedi/evaluate/gradual/annotation.py +++ b/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() diff --git a/jedi/evaluate/gradual/typing.py b/jedi/evaluate/gradual/typing.py index 351dc856..3e546d52 100644 --- a/jedi/evaluate/gradual/typing.py +++ b/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)),