def _create(evaluator, access_handle, parent_context, *args):
module_node, tree_node, path = _find_syntax_node_name(evaluator, access_handle)
compiled_object = create_cached_compiled_object(
evaluator, access_handle, parent_context=parent_context.compiled_object)
if tree_node is None:
return compiled_object
if parent_context.tree_node.get_root_node() == module_node:
module_context = parent_context.get_root_context()
else:
module_context = ModuleContext(evaluator, module_node, path=path)
# TODO this __name__ is probably wrong.
name = compiled_object.get_root_context().py__name__()
imports.add_module(evaluator, name, module_context)
tree_context = module_context.create_context(
tree_node,
node_is_context=True,
node_is_object=True
)
if tree_node.type == 'classdef':
if not access_handle.is_class():
# Is an instance, not a class.
tree_context, = tree_context.execute_evaluated()
return MixedObject(
evaluator,
parent_context,
compiled_object,
tree_context=tree_context
)
def _create(evaluator, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object(
evaluator,
access_handle,
parent_context=parent_context and parent_context.compiled_object)
# TODO accessing this is bad, but it probably doesn't matter that much,
# because we're working with interpreteters only here.
python_object = access_handle.access._obj
result = _find_syntax_node_name(evaluator, python_object)
if result is None:
# TODO Care about generics from stuff like `[1]` and don't return like this.
if type(python_object) in (dict, list, tuple):
return ContextSet({compiled_object})
tree_contexts = to_stub(compiled_object)
if not tree_contexts:
return ContextSet({compiled_object})
else:
module_node, tree_node, file_io, code_lines = result
if parent_context is None:
# TODO this __name__ is probably wrong.
name = compiled_object.get_root_context().py__name__()
string_names = tuple(name.split('.'))
module_context = ModuleContext(
evaluator,
module_node,
file_io=file_io,
string_names=string_names,
code_lines=code_lines,
is_package=hasattr(compiled_object, 'py__path__'),
)
if name is not None:
evaluator.module_cache.add(string_names,
ContextSet([module_context]))
else:
if parent_context.tree_node.get_root_node() != module_node:
# This happens e.g. when __module__ is wrong, or when using
# TypeVar('foo'), where Jedi uses 'foo' as the name and
# Python's TypeVar('foo').__module__ will be typing.
return ContextSet({compiled_object})
module_context = parent_context.get_root_context()
tree_contexts = ContextSet({
module_context.create_context(tree_node,
node_is_context=True,
node_is_object=True)
})
if tree_node.type == 'classdef':
if not access_handle.is_class():
# Is an instance, not a class.
tree_contexts = tree_contexts.execute_evaluated()
return ContextSet(
MixedObject(compiled_object, tree_context=tree_context)
for tree_context in tree_contexts)
def infer(self):
# TODO use logic from compiled.CompiledObjectFilter
access_paths = self.parent_context.access_handle.getattr_paths(
self.string_name, default=None)
assert len(access_paths)
contexts = [None]
for access in access_paths:
contexts = ContextSet.from_sets(
_create(self._evaluator, access, parent_context=c)
if c is None or isinstance(c, MixedObject) else ContextSet(
{create_cached_compiled_object(c.evaluator, access, c)})
for c in contexts)
return contexts
def infer(self):
# TODO use logic from compiled.CompiledObjectFilter
access_paths = self.parent_context.access_handle.getattr_paths(
self.string_name, default=None)
assert len(access_paths)
context = None
for access in access_paths:
if context is None or isinstance(context, MixedObject):
context = _create(self._evaluator,
access,
parent_context=context)
else:
context = create_cached_compiled_object(
context.evaluator, access, context)
return ContextSet([context])
def _create(evaluator, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object(
evaluator,
access_handle,
parent_context=parent_context and parent_context.compiled_object)
result = _find_syntax_node_name(evaluator, access_handle)
# TODO use stub contexts here. If we do that we probably have to care about
# generics from stuff like `[1]`.
if result is None:
return compiled_object
module_node, tree_node, file_io, code_lines = result
if parent_context is None:
# TODO this __name__ is probably wrong.
name = compiled_object.get_root_context().py__name__()
string_names = tuple(name.split('.'))
module_context = ModuleContext(
evaluator,
module_node,
file_io=file_io,
string_names=string_names,
code_lines=code_lines,
is_package=hasattr(compiled_object, 'py__path__'),
)
if name is not None:
evaluator.module_cache.add(string_names,
ContextSet([module_context]))
else:
assert parent_context.tree_node.get_root_node() == module_node
module_context = parent_context.get_root_context()
tree_context = module_context.create_context(tree_node,
node_is_context=True,
node_is_object=True)
if tree_node.type == 'classdef':
if not access_handle.is_class():
# Is an instance, not a class.
tree_context, = execute_evaluated(tree_context)
return MixedObject(compiled_object, tree_context=tree_context)
def _create(evaluator, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object(
evaluator,
access_handle,
parent_context=parent_context.compiled_object)
result = _find_syntax_node_name(evaluator, access_handle)
if result is None:
return compiled_object
module_node, tree_node, path, code_lines = result
if parent_context.tree_node.get_root_node() == module_node:
module_context = parent_context.get_root_context()
else:
# TODO this __name__ is probably wrong.
name = compiled_object.get_root_context().py__name__()
string_names = tuple(name.split('.'))
module_context = ModuleContext(
evaluator,
module_node,
path=path,
string_names=string_names,
code_lines=code_lines,
is_package=hasattr(compiled_object, 'py__path__'),
)
if name is not None:
evaluator.module_cache.add(string_names,
ContextSet([module_context]))
tree_context = module_context.create_context(tree_node,
node_is_context=True,
node_is_object=True)
if tree_node.type == 'classdef':
if not access_handle.is_class():
# Is an instance, not a class.
tree_context, = execute_evaluated(tree_context)
return MixedObject(evaluator,
parent_context,
compiled_object,
tree_context=tree_context)
def _create(evaluator, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object(
evaluator, access_handle, parent_context=parent_context.compiled_object)
result = _find_syntax_node_name(evaluator, access_handle)
if result is None:
return compiled_object
module_node, tree_node, path, code_lines = result
if parent_context.tree_node.get_root_node() == module_node:
module_context = parent_context.get_root_context()
else:
module_context = ModuleContext(
evaluator, module_node,
path=path,
code_lines=code_lines,
)
# TODO this __name__ is probably wrong.
name = compiled_object.get_root_context().py__name__()
if name is not None:
imports.add_module_to_cache(evaluator, name, module_context)
tree_context = module_context.create_context(
tree_node,
node_is_context=True,
node_is_object=True
)
if tree_node.type == 'classdef':
if not access_handle.is_class():
# Is an instance, not a class.
tree_context, = tree_context.execute_evaluated()
return MixedObject(
evaluator,
parent_context,
compiled_object,
tree_context=tree_context
)
