forked from VimPlug/jedi
406 lines
14 KiB
Python
406 lines
14 KiB
Python
"""
|
|
PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
|
|
through function annotations. There is a strong suggestion in this document
|
|
that only the type of type hinting defined in PEP0484 should be allowed
|
|
as annotations in future python versions.
|
|
"""
|
|
|
|
import re
|
|
|
|
from parso import ParserSyntaxError, parse
|
|
|
|
from jedi._compatibility import force_unicode
|
|
from jedi.inference.cache import infer_state_method_cache
|
|
from jedi.inference.base_value import ContextSet, NO_VALUES
|
|
from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \
|
|
AbstractAnnotatedClass
|
|
from jedi.inference.gradual.typing import GenericClass
|
|
from jedi.inference.helpers import is_string
|
|
from jedi.inference.compiled import builtin_from_name
|
|
from jedi import debug
|
|
from jedi import parser_utils
|
|
|
|
|
|
def infer_annotation(value, annotation):
|
|
"""
|
|
Inferes an annotation node. This means that it inferes the part of
|
|
`int` here:
|
|
|
|
foo: int = 3
|
|
|
|
Also checks for forward references (strings)
|
|
"""
|
|
value_set = value.infer_node(annotation)
|
|
if len(value_set) != 1:
|
|
debug.warning("Inferred typing index %s should lead to 1 object, "
|
|
" not %s" % (annotation, value_set))
|
|
return value_set
|
|
|
|
inferred_value = list(value_set)[0]
|
|
if is_string(inferred_value):
|
|
result = _get_forward_reference_node(value, inferred_value.get_safe_value())
|
|
if result is not None:
|
|
return value.infer_node(result)
|
|
return value_set
|
|
|
|
|
|
def _infer_annotation_string(value, string, index=None):
|
|
node = _get_forward_reference_node(value, string)
|
|
if node is None:
|
|
return NO_VALUES
|
|
|
|
value_set = value.infer_node(node)
|
|
if index is not None:
|
|
value_set = value_set.filter(
|
|
lambda value: value.array_type == u'tuple' # noqa
|
|
and len(list(value.py__iter__())) >= index
|
|
).py__simple_getitem__(index)
|
|
return value_set
|
|
|
|
|
|
def _get_forward_reference_node(value, string):
|
|
try:
|
|
new_node = value.infer_state.grammar.parse(
|
|
force_unicode(string),
|
|
start_symbol='eval_input',
|
|
error_recovery=False
|
|
)
|
|
except ParserSyntaxError:
|
|
debug.warning('Annotation not parsed: %s' % string)
|
|
return None
|
|
else:
|
|
module = value.tree_node.get_root_node()
|
|
parser_utils.move(new_node, module.end_pos[0])
|
|
new_node.parent = value.tree_node
|
|
return new_node
|
|
|
|
|
|
def _split_comment_param_declaration(decl_text):
|
|
"""
|
|
Split decl_text on commas, but group generic expressions
|
|
together.
|
|
|
|
For example, given "foo, Bar[baz, biz]" we return
|
|
['foo', 'Bar[baz, biz]'].
|
|
|
|
"""
|
|
try:
|
|
node = parse(decl_text, error_recovery=False).children[0]
|
|
except ParserSyntaxError:
|
|
debug.warning('Comment annotation is not valid Python: %s' % decl_text)
|
|
return []
|
|
|
|
if node.type == 'name':
|
|
return [node.get_code().strip()]
|
|
|
|
params = []
|
|
try:
|
|
children = node.children
|
|
except AttributeError:
|
|
return []
|
|
else:
|
|
for child in children:
|
|
if child.type in ['name', 'atom_expr', 'power']:
|
|
params.append(child.get_code().strip())
|
|
|
|
return params
|
|
|
|
|
|
@infer_state_method_cache()
|
|
def infer_param(execution_value, param):
|
|
values = _infer_param(execution_value, param)
|
|
infer_state = execution_value.infer_state
|
|
if param.star_count == 1:
|
|
tuple_ = builtin_from_name(infer_state, 'tuple')
|
|
return ContextSet([GenericClass(
|
|
tuple_,
|
|
generics=(values,),
|
|
) for c in values])
|
|
elif param.star_count == 2:
|
|
dct = builtin_from_name(infer_state, 'dict')
|
|
return ContextSet([GenericClass(
|
|
dct,
|
|
generics=(ContextSet([builtin_from_name(infer_state, 'str')]), values),
|
|
) for c in values])
|
|
pass
|
|
return values
|
|
|
|
|
|
def _infer_param(execution_value, param):
|
|
"""
|
|
Infers the type of a function parameter, using type annotations.
|
|
"""
|
|
annotation = param.annotation
|
|
if annotation is None:
|
|
# If no Python 3-style annotation, look for a Python 2-style comment
|
|
# annotation.
|
|
# Identify parameters to function in the same sequence as they would
|
|
# appear in a type comment.
|
|
all_params = [child for child in param.parent.children
|
|
if child.type == 'param']
|
|
|
|
node = param.parent.parent
|
|
comment = parser_utils.get_following_comment_same_line(node)
|
|
if comment is None:
|
|
return NO_VALUES
|
|
|
|
match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment)
|
|
if not match:
|
|
return NO_VALUES
|
|
params_comments = _split_comment_param_declaration(match.group(1))
|
|
|
|
# Find the specific param being investigated
|
|
index = all_params.index(param)
|
|
# If the number of parameters doesn't match length of type comment,
|
|
# ignore first parameter (assume it's self).
|
|
if len(params_comments) != len(all_params):
|
|
debug.warning(
|
|
"Comments length != Params length %s %s",
|
|
params_comments, all_params
|
|
)
|
|
from jedi.inference.value.instance import InstanceArguments
|
|
if isinstance(execution_value.var_args, InstanceArguments):
|
|
if index == 0:
|
|
# Assume it's self, which is already handled
|
|
return NO_VALUES
|
|
index -= 1
|
|
if index >= len(params_comments):
|
|
return NO_VALUES
|
|
|
|
param_comment = params_comments[index]
|
|
return _infer_annotation_string(
|
|
execution_value.function_value.get_default_param_value(),
|
|
param_comment
|
|
)
|
|
# Annotations are like default params and resolve in the same way.
|
|
value = execution_value.function_value.get_default_param_value()
|
|
return infer_annotation(value, annotation)
|
|
|
|
|
|
def py__annotations__(funcdef):
|
|
dct = {}
|
|
for function_param in funcdef.get_params():
|
|
param_annotation = function_param.annotation
|
|
if param_annotation is not None:
|
|
dct[function_param.name.value] = param_annotation
|
|
|
|
return_annotation = funcdef.annotation
|
|
if return_annotation:
|
|
dct['return'] = return_annotation
|
|
return dct
|
|
|
|
|
|
@infer_state_method_cache()
|
|
def infer_return_types(function_execution_value):
|
|
"""
|
|
Infers the type of a function's return value,
|
|
according to type annotations.
|
|
"""
|
|
all_annotations = py__annotations__(function_execution_value.tree_node)
|
|
annotation = all_annotations.get("return", None)
|
|
if annotation is None:
|
|
# If there is no Python 3-type annotation, look for a Python 2-type annotation
|
|
node = function_execution_value.tree_node
|
|
comment = parser_utils.get_following_comment_same_line(node)
|
|
if comment is None:
|
|
return NO_VALUES
|
|
|
|
match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment)
|
|
if not match:
|
|
return NO_VALUES
|
|
|
|
return _infer_annotation_string(
|
|
function_execution_value.function_value.get_default_param_value(),
|
|
match.group(1).strip()
|
|
).execute_annotation()
|
|
if annotation is None:
|
|
return NO_VALUES
|
|
|
|
value = function_execution_value.function_value.get_default_param_value()
|
|
unknown_type_vars = list(find_unknown_type_vars(value, annotation))
|
|
annotation_values = infer_annotation(value, annotation)
|
|
if not unknown_type_vars:
|
|
return annotation_values.execute_annotation()
|
|
|
|
type_var_dict = infer_type_vars_for_execution(function_execution_value, all_annotations)
|
|
|
|
return ContextSet.from_sets(
|
|
ann.define_generics(type_var_dict)
|
|
if isinstance(ann, (AbstractAnnotatedClass, TypeVar)) else ContextSet({ann})
|
|
for ann in annotation_values
|
|
).execute_annotation()
|
|
|
|
|
|
def infer_type_vars_for_execution(execution_value, annotation_dict):
|
|
"""
|
|
Some functions use type vars that are not defined by the class, but rather
|
|
only defined in the function. See for example `iter`. In those cases we
|
|
want to:
|
|
|
|
1. Search for undefined type vars.
|
|
2. Infer type vars with the execution state we have.
|
|
3. Return the union of all type vars that have been found.
|
|
"""
|
|
value = execution_value.function_value.get_default_param_value()
|
|
|
|
annotation_variable_results = {}
|
|
executed_params, _ = execution_value.get_executed_params_and_issues()
|
|
for executed_param in executed_params:
|
|
try:
|
|
annotation_node = annotation_dict[executed_param.string_name]
|
|
except KeyError:
|
|
continue
|
|
|
|
annotation_variables = find_unknown_type_vars(value, annotation_node)
|
|
if annotation_variables:
|
|
# Infer unknown type var
|
|
annotation_value_set = value.infer_node(annotation_node)
|
|
star_count = executed_param._param_node.star_count
|
|
actual_value_set = executed_param.infer(use_hints=False)
|
|
if star_count == 1:
|
|
actual_value_set = actual_value_set.merge_types_of_iterate()
|
|
elif star_count == 2:
|
|
# TODO _dict_values is not public.
|
|
actual_value_set = actual_value_set.try_merge('_dict_values')
|
|
for ann in annotation_value_set:
|
|
_merge_type_var_dicts(
|
|
annotation_variable_results,
|
|
_infer_type_vars(ann, actual_value_set),
|
|
)
|
|
|
|
return annotation_variable_results
|
|
|
|
|
|
def _merge_type_var_dicts(base_dict, new_dict):
|
|
for type_var_name, values in new_dict.items():
|
|
try:
|
|
base_dict[type_var_name] |= values
|
|
except KeyError:
|
|
base_dict[type_var_name] = values
|
|
|
|
|
|
def _infer_type_vars(annotation_value, value_set):
|
|
"""
|
|
This function tries to find information about undefined type vars and
|
|
returns a dict from type var name to value set.
|
|
|
|
This is for example important to understand what `iter([1])` returns.
|
|
According to typeshed, `iter` returns an `Iterator[_T]`:
|
|
|
|
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
|
|
|
|
This functions would generate `int` for `_T` in this case, because it
|
|
unpacks the `Iterable`.
|
|
"""
|
|
type_var_dict = {}
|
|
if isinstance(annotation_value, TypeVar):
|
|
return {annotation_value.py__name__(): value_set.py__class__()}
|
|
elif isinstance(annotation_value, LazyGenericClass):
|
|
name = annotation_value.py__name__()
|
|
if name == 'Iterable':
|
|
given = annotation_value.get_generics()
|
|
if given:
|
|
for nested_annotation_value in given[0]:
|
|
_merge_type_var_dicts(
|
|
type_var_dict,
|
|
_infer_type_vars(
|
|
nested_annotation_value,
|
|
value_set.merge_types_of_iterate()
|
|
)
|
|
)
|
|
elif name == 'Mapping':
|
|
given = annotation_value.get_generics()
|
|
if len(given) == 2:
|
|
for value in value_set:
|
|
try:
|
|
method = value.get_mapping_item_values
|
|
except AttributeError:
|
|
continue
|
|
key_values, value_values = method()
|
|
|
|
for nested_annotation_value in given[0]:
|
|
_merge_type_var_dicts(
|
|
type_var_dict,
|
|
_infer_type_vars(
|
|
nested_annotation_value,
|
|
key_values,
|
|
)
|
|
)
|
|
for nested_annotation_value in given[1]:
|
|
_merge_type_var_dicts(
|
|
type_var_dict,
|
|
_infer_type_vars(
|
|
nested_annotation_value,
|
|
value_values,
|
|
)
|
|
)
|
|
return type_var_dict
|
|
|
|
|
|
def find_type_from_comment_hint_for(value, node, name):
|
|
return _find_type_from_comment_hint(value, node, node.children[1], name)
|
|
|
|
|
|
def find_type_from_comment_hint_with(value, node, name):
|
|
assert len(node.children[1].children) == 3, \
|
|
"Can only be here when children[1] is 'foo() as f'"
|
|
varlist = node.children[1].children[2]
|
|
return _find_type_from_comment_hint(value, node, varlist, name)
|
|
|
|
|
|
def find_type_from_comment_hint_assign(value, node, name):
|
|
return _find_type_from_comment_hint(value, node, node.children[0], name)
|
|
|
|
|
|
def _find_type_from_comment_hint(value, node, varlist, name):
|
|
index = None
|
|
if varlist.type in ("testlist_star_expr", "exprlist", "testlist"):
|
|
# something like "a, b = 1, 2"
|
|
index = 0
|
|
for child in varlist.children:
|
|
if child == name:
|
|
break
|
|
if child.type == "operator":
|
|
continue
|
|
index += 1
|
|
else:
|
|
return []
|
|
|
|
comment = parser_utils.get_following_comment_same_line(node)
|
|
if comment is None:
|
|
return []
|
|
match = re.match(r"^#\s*type:\s*([^#]*)", comment)
|
|
if match is None:
|
|
return []
|
|
return _infer_annotation_string(
|
|
value, match.group(1).strip(), index
|
|
).execute_annotation()
|
|
|
|
|
|
def find_unknown_type_vars(value, node):
|
|
def check_node(node):
|
|
if node.type in ('atom_expr', 'power'):
|
|
trailer = node.children[-1]
|
|
if trailer.type == 'trailer' and trailer.children[0] == '[':
|
|
for subscript_node in _unpack_subscriptlist(trailer.children[1]):
|
|
check_node(subscript_node)
|
|
else:
|
|
type_var_set = value.infer_node(node)
|
|
for type_var in type_var_set:
|
|
if isinstance(type_var, TypeVar) and type_var not in found:
|
|
found.append(type_var)
|
|
|
|
found = [] # We're not using a set, because the order matters.
|
|
check_node(node)
|
|
return found
|
|
|
|
|
|
def _unpack_subscriptlist(subscriptlist):
|
|
if subscriptlist.type == 'subscriptlist':
|
|
for subscript in subscriptlist.children[::2]:
|
|
if subscript.type != 'subscript':
|
|
yield subscript
|
|
else:
|
|
if subscriptlist.type != 'subscript':
|
|
yield subscriptlist
|