ValueualizedName -> ContextualizedName

Basically a change back to an older version

jedi/inference/__init__.py

@@ -75,7 +75,7 @@ from jedi.inference import recursion
 from jedi.inference.cache import inference_state_function_cache
 from jedi.inference import helpers
 from jedi.inference.names import TreeNameDefinition, ParamName
-from jedi.inference.base_value import ValueualizedName, ValueualizedNode, \
+from jedi.inference.base_value import ContextualizedName, ContextualizedNode, \
     ValueSet, NO_VALUES, iterate_values
 from jedi.inference.value import ClassValue, FunctionValue, \
     AnonymousInstance, BoundMethod
@@ -255,9 +255,9 @@ class InferenceState(object):
                     return infer_expr_stmt(context, def_, name)
             if type_ == 'for_stmt':
                 container_types = context.infer_node(def_.children[3])
-                cn = ValueualizedNode(context, def_.children[3])
+                cn = ContextualizedNode(context, def_.children[3])
                 for_types = iterate_values(container_types, cn)
-                c_node = ValueualizedName(context, name)
+                c_node = ContextualizedName(context, name)
                 return check_tuple_assignments(c_node, for_types)
             if type_ in ('import_from', 'import_name'):
                 return imports.infer_import(context, name)

jedi/inference/arguments.py

@@ -9,7 +9,7 @@ from jedi.inference import analysis
 from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
     LazyTreeValue, get_merged_lazy_value
 from jedi.inference.names import ParamName, TreeNameDefinition
-from jedi.inference.base_value import NO_VALUES, ValueSet, ValueualizedNode
+from jedi.inference.base_value import NO_VALUES, ValueSet, ContextualizedNode
 from jedi.inference.value import iterable
 from jedi.inference.cache import inference_state_as_method_param_cache
 from jedi.inference.param import get_executed_params_and_issues, ExecutedParam
@@ -302,9 +302,9 @@ class TreeArguments(AbstractArguments):
                 break
 
         if arguments.argument_node is not None:
-            return [ValueualizedNode(arguments.context, arguments.argument_node)]
+            return [ContextualizedNode(arguments.context, arguments.argument_node)]
         if arguments.trailer is not None:
-            return [ValueualizedNode(arguments.context, arguments.trailer)]
+            return [ContextualizedNode(arguments.context, arguments.trailer)]
         return []
 
 

jedi/inference/base_value.py

@@ -292,7 +292,7 @@ class TreeValue(Value):
         return '<%s: %s>' % (self.__class__.__name__, self.tree_node)
 
 
-class ValueualizedNode(object):
+class ContextualizedNode(object):
     def __init__(self, context, node):
         self.context = context
         self.node = node
@@ -307,7 +307,7 @@ class ValueualizedNode(object):
         return '<%s: %s in %s>' % (self.__class__.__name__, self.node, self.context)
 
 
-class ValueualizedName(ValueualizedNode):
+class ContextualizedName(ContextualizedNode):
     # TODO merge with TreeNameDefinition?!
     @property
     def name(self):

jedi/inference/syntax_tree.py

@@ -8,8 +8,8 @@ from parso.python import tree
 from jedi._compatibility import force_unicode, unicode
 from jedi import debug
 from jedi import parser_utils
-from jedi.inference.base_value import ValueSet, NO_VALUES, ValueualizedNode, \
+from jedi.inference.base_value import ValueSet, NO_VALUES, ContextualizedNode, \
-    ValueualizedName, iterator_to_value_set, iterate_values
+    ContextualizedName, iterator_to_value_set, iterate_values
 from jedi.inference.lazy_value import LazyTreeValue
 from jedi.inference import compiled
 from jedi.inference import recursion
@@ -157,7 +157,7 @@ def infer_trailer(context, atom_values, trailer):
         trailer_op, node, _ = trailer.children
         return atom_values.get_item(
             _infer_subscript_list(context, node),
-            ValueualizedNode(context, trailer)
+            ContextualizedNode(context, trailer)
         )
     else:
         debug.dbg('infer_trailer: %s in %s', trailer, atom_values)
@@ -300,7 +300,7 @@ def _infer_expr_stmt(context, stmt, seek_name=None):
     value_set = context.infer_node(rhs)
 
     if seek_name:
-        c_node = ValueualizedName(context, seek_name)
+        c_node = ContextualizedName(context, seek_name)
         value_set = check_tuple_assignments(c_node, value_set)
 
     first_operator = next(stmt.yield_operators(), None)
@@ -318,7 +318,7 @@ def _infer_expr_stmt(context, stmt, seek_name=None):
             # only in for loops without clutter, because they are
             # predictable. Also only do it, if the variable is not a tuple.
             node = for_stmt.get_testlist()
-            cn = ValueualizedNode(context, node)
+            cn = ContextualizedNode(context, node)
             ordered = list(cn.infer().iterate(cn))
 
             for lazy_value in ordered:
@@ -595,13 +595,13 @@ def tree_name_to_values(inference_state, context, tree_name):
         try:
             types = context.predefined_names[node][tree_name.value]
         except KeyError:
-            cn = ValueualizedNode(context, node.children[3])
+            cn = ContextualizedNode(context, node.children[3])
             for_types = iterate_values(
                 cn.infer(),
                 valueualized_node=cn,
                 is_async=node.parent.type == 'async_stmt',
             )
-            c_node = ValueualizedName(context, tree_name)
+            c_node = ContextualizedName(context, tree_name)
             types = check_tuple_assignments(c_node, for_types)
     elif typ == 'expr_stmt':
         types = _remove_statements(context, node, tree_name)
@@ -680,7 +680,7 @@ def check_tuple_assignments(valueualized_name, value_set):
     """
     lazy_value = None
     for index, node in valueualized_name.assignment_indexes():
-        cn = ValueualizedNode(valueualized_name.context, node)
+        cn = ContextualizedNode(valueualized_name.context, node)
         iterated = value_set.iterate(cn)
         if isinstance(index, slice):
             # For no star unpacking is not possible.

jedi/inference/sys_path.py

@@ -2,7 +2,7 @@ import os
 
 from jedi._compatibility import unicode, force_unicode, all_suffixes
 from jedi.inference.cache import inference_state_method_cache
-from jedi.inference.base_value import ValueualizedNode
+from jedi.inference.base_value import ContextualizedNode
 from jedi.inference.helpers import is_string
 from jedi.common.utils import traverse_parents
 from jedi.parser_utils import get_cached_code_lines
@@ -60,7 +60,7 @@ def _paths_from_assignment(module_context, expr_stmt):
         except AssertionError:
             continue
 
-        cn = ValueualizedNode(module_context.create_context(expr_stmt), expr_stmt)
+        cn = ContextualizedNode(module_context.create_context(expr_stmt), expr_stmt)
         for lazy_value in cn.infer().iterate(cn):
             for value in lazy_value.infer():
                 if is_string(value):

jedi/inference/value/function.py

@@ -12,7 +12,7 @@ from jedi.inference.signature import TreeSignature
 from jedi.inference.arguments import AnonymousArguments
 from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter
 from jedi.inference.names import ValueName, AbstractNameDefinition, ParamName
-from jedi.inference.base_value import ValueualizedNode, NO_VALUES, \
+from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \
     ValueSet, TreeValue, ValueWrapper
 from jedi.inference.lazy_value import LazyKnownValues, LazyKnownValue, \
     LazyTreeValue
@@ -224,7 +224,7 @@ class FunctionExecutionContext(AbstractContext):
 
         node = yield_expr.children[1]
         if node.type == 'yield_arg':  # It must be a yield from.
-            cn = ValueualizedNode(self, node.children[1])
+            cn = ContextualizedNode(self, node.children[1])
             for lazy_value in cn.infer().iterate(cn):
                 yield lazy_value
         else:
@@ -269,7 +269,7 @@ class FunctionExecutionContext(AbstractContext):
                         yield result
             else:
                 input_node = for_stmt.get_testlist()
-                cn = ValueualizedNode(self, input_node)
+                cn = ContextualizedNode(self, input_node)
                 ordered = cn.infer().iterate(cn)
                 ordered = list(ordered)
                 for lazy_value in ordered:

jedi/inference/value/iterable.py

@@ -38,7 +38,7 @@ from jedi.inference.cache import inference_state_method_cache
 from jedi.inference.filters import ParserTreeFilter, LazyAttributeOverwrite, \
     publish_method
 from jedi.inference.base_value import ValueSet, Value, NO_VALUES, \
-    TreeValue, ValueualizedNode, iterate_values, HelperValueMixin, _sentinel
+    TreeValue, ContextualizedNode, iterate_values, HelperValueMixin, _sentinel
 from jedi.parser_utils import get_sync_comp_fors
 
 
@@ -171,7 +171,7 @@ class ComprehensionMixin(object):
         input_types = parent_context.infer_node(input_node)
         # TODO: simulate await if self.is_async
 
-        cn = ValueualizedNode(parent_context, input_node)
+        cn = ContextualizedNode(parent_context, input_node)
         iterated = input_types.iterate(cn, is_async=is_async)
         exprlist = comp_for.children[1]
         for i, lazy_value in enumerate(iterated):

jedi/plugins/stdlib.py

@@ -21,7 +21,7 @@ from jedi.inference.arguments import ValuesArguments, \
 from jedi.inference import analysis
 from jedi.inference import compiled
 from jedi.inference.value.instance import BoundMethod, InstanceArguments
-from jedi.inference.base_value import ValueualizedNode, \
+from jedi.inference.base_value import ContextualizedNode, \
     NO_VALUES, ValueSet, ValueWrapper, LazyValueWrapper
 from jedi.inference.value import ClassValue, ModuleValue, \
     FunctionExecutionContext
@@ -304,7 +304,7 @@ def builtins_reversed(sequences, obj, arguments):
     key, lazy_value = next(arguments.unpack())
     cn = None
     if isinstance(lazy_value, LazyTreeValue):
-        cn = ValueualizedNode(lazy_value.context, lazy_value.data)
+        cn = ContextualizedNode(lazy_value.context, lazy_value.data)
     ordered = list(sequences.iterate(cn))
 
     # Repack iterator values and then run it the normal way. This is