[config.git] / djavu-asus / elpy / rpc-venv / lib / python3.11 / site-packages / jedi / inference / star_args.py

"""
This module is responsible for inferring *args and **kwargs for signatures.

This means for example in this case::

    def foo(a, b, c): ...

    def bar(*args):
        return foo(1, *args)

The signature here for bar should be `bar(b, c)` instead of bar(*args).
"""
from inspect import Parameter

from parso import tree

from jedi.inference.utils import to_list
from jedi.inference.names import ParamNameWrapper
from jedi.inference.helpers import is_big_annoying_library


def _iter_nodes_for_param(param_name):
    from parso.python.tree import search_ancestor
    from jedi.inference.arguments import TreeArguments

    execution_context = param_name.parent_context
    # Walk up the parso tree to get the FunctionNode we want. We use the parso
    # tree rather than going via the execution context so that we're agnostic of
    # the specific scope we're evaluating within (i.e: module or function,
    # etc.).
    function_node = tree.search_ancestor(param_name.tree_name, 'funcdef', 'lambdef')
    module_node = function_node.get_root_node()
    start = function_node.children[-1].start_pos
    end = function_node.children[-1].end_pos
    for name in module_node.get_used_names().get(param_name.string_name):
        if start <= name.start_pos < end:
            # Is used in the function
            argument = name.parent
            if argument.type == 'argument' \
                    and argument.children[0] == '*' * param_name.star_count:
                trailer = search_ancestor(argument, 'trailer')
                if trailer is not None:  # Make sure we're in a function
                    context = execution_context.create_context(trailer)
                    if _goes_to_param_name(param_name, context, name):
                        values = _to_callables(context, trailer)

                        args = TreeArguments.create_cached(
                            execution_context.inference_state,
                            context=context,
                            argument_node=trailer.children[1],
                            trailer=trailer,
                        )
                        for c in values:
                            yield c, args


def _goes_to_param_name(param_name, context, potential_name):
    if potential_name.type != 'name':
        return False
    from jedi.inference.names import TreeNameDefinition
    found = TreeNameDefinition(context, potential_name).goto()
    return any(param_name.parent_context == p.parent_context
               and param_name.start_pos == p.start_pos
               for p in found)


def _to_callables(context, trailer):
    from jedi.inference.syntax_tree import infer_trailer

    atom_expr = trailer.parent
    index = atom_expr.children[0] == 'await'
    # Infer atom first
    values = context.infer_node(atom_expr.children[index])
    for trailer2 in atom_expr.children[index + 1:]:
        if trailer == trailer2:
            break
        values = infer_trailer(context, values, trailer2)
    return values


def _remove_given_params(arguments, param_names):
    count = 0
    used_keys = set()
    for key, _ in arguments.unpack():
        if key is None:
            count += 1
        else:
            used_keys.add(key)

    for p in param_names:
        if count and p.maybe_positional_argument():
            count -= 1
            continue
        if p.string_name in used_keys and p.maybe_keyword_argument():
            continue
        yield p


@to_list
def process_params(param_names, star_count=3):  # default means both * and **
    if param_names:
        if is_big_annoying_library(param_names[0].parent_context):
            # At first this feature can look innocent, but it does a lot of
            # type inference in some cases, so we just ditch it.
            yield from param_names
            return

    used_names = set()
    arg_callables = []
    kwarg_callables = []

    kw_only_names = []
    kwarg_names = []
    arg_names = []
    original_arg_name = None
    original_kwarg_name = None
    for p in param_names:
        kind = p.get_kind()
        if kind == Parameter.VAR_POSITIONAL:
            if star_count & 1:
                arg_callables = _iter_nodes_for_param(p)
                original_arg_name = p
        elif p.get_kind() == Parameter.VAR_KEYWORD:
            if star_count & 2:
                kwarg_callables = list(_iter_nodes_for_param(p))
                original_kwarg_name = p
        elif kind == Parameter.KEYWORD_ONLY:
            if star_count & 2:
                kw_only_names.append(p)
        elif kind == Parameter.POSITIONAL_ONLY:
            if star_count & 1:
                yield p
        else:
            if star_count == 1:
                yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
            elif star_count == 2:
                kw_only_names.append(ParamNameFixedKind(p, Parameter.KEYWORD_ONLY))
            else:
                used_names.add(p.string_name)
                yield p

    # First process *args
    longest_param_names = ()
    found_arg_signature = False
    found_kwarg_signature = False
    for func_and_argument in arg_callables:
        func, arguments = func_and_argument
        new_star_count = star_count
        if func_and_argument in kwarg_callables:
            kwarg_callables.remove(func_and_argument)
        else:
            new_star_count = 1

        for signature in func.get_signatures():
            found_arg_signature = True
            if new_star_count == 3:
                found_kwarg_signature = True
            args_for_this_func = []
            for p in process_params(
                    list(_remove_given_params(
                        arguments,
                        signature.get_param_names(resolve_stars=False)
                    )), new_star_count):
                if p.get_kind() == Parameter.VAR_KEYWORD:
                    kwarg_names.append(p)
                elif p.get_kind() == Parameter.VAR_POSITIONAL:
                    arg_names.append(p)
                elif p.get_kind() == Parameter.KEYWORD_ONLY:
                    kw_only_names.append(p)
                else:
                    args_for_this_func.append(p)
            if len(args_for_this_func) > len(longest_param_names):
                longest_param_names = args_for_this_func

    for p in longest_param_names:
        if star_count == 1 and p.get_kind() != Parameter.VAR_POSITIONAL:
            yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
        else:
            if p.get_kind() == Parameter.POSITIONAL_OR_KEYWORD:
                used_names.add(p.string_name)
            yield p

    if not found_arg_signature and original_arg_name is not None:
        yield original_arg_name
    elif arg_names:
        yield arg_names[0]

    # Then process **kwargs
    for func, arguments in kwarg_callables:
        for signature in func.get_signatures():
            found_kwarg_signature = True
            for p in process_params(
                    list(_remove_given_params(
                        arguments,
                        signature.get_param_names(resolve_stars=False)
                    )), star_count=2):
                if p.get_kind() == Parameter.VAR_KEYWORD:
                    kwarg_names.append(p)
                elif p.get_kind() == Parameter.KEYWORD_ONLY:
                    kw_only_names.append(p)

    for p in kw_only_names:
        if p.string_name in used_names:
            continue
        yield p
        used_names.add(p.string_name)

    if not found_kwarg_signature and original_kwarg_name is not None:
        yield original_kwarg_name
    elif kwarg_names:
        yield kwarg_names[0]


class ParamNameFixedKind(ParamNameWrapper):
    def __init__(self, param_name, new_kind):
        super().__init__(param_name)
        self._new_kind = new_kind

    def get_kind(self):
        return self._new_kind
Commit	Line	Data
53e6db90 DC	1	"""
	2	This module is responsible for inferring args and *kwargs for signatures.
	3
	4	This means for example in this case::
	5
	6	def foo(a, b, c): ...
	7
	8	def bar(*args):
	9	return foo(1, *args)
	10
	11	The signature here for bar should be `bar(b, c)` instead of bar(*args).
	12	"""
	13	from inspect import Parameter
	14
	15	from parso import tree
	16
	17	from jedi.inference.utils import to_list
	18	from jedi.inference.names import ParamNameWrapper
	19	from jedi.inference.helpers import is_big_annoying_library
	20
	21
	22	def _iter_nodes_for_param(param_name):
	23	from parso.python.tree import search_ancestor
	24	from jedi.inference.arguments import TreeArguments
	25
	26	execution_context = param_name.parent_context
	27	# Walk up the parso tree to get the FunctionNode we want. We use the parso
	28	# tree rather than going via the execution context so that we're agnostic of
	29	# the specific scope we're evaluating within (i.e: module or function,
	30	# etc.).
	31	function_node = tree.search_ancestor(param_name.tree_name, 'funcdef', 'lambdef')
	32	module_node = function_node.get_root_node()
	33	start = function_node.children[-1].start_pos
	34	end = function_node.children[-1].end_pos
	35	for name in module_node.get_used_names().get(param_name.string_name):
	36	if start <= name.start_pos < end:
	37	# Is used in the function
	38	argument = name.parent
	39	if argument.type == 'argument' \
	40	and argument.children[0] == '' param_name.star_count:
	41	trailer = search_ancestor(argument, 'trailer')
	42	if trailer is not None: # Make sure we're in a function
	43	context = execution_context.create_context(trailer)
	44	if _goes_to_param_name(param_name, context, name):
	45	values = _to_callables(context, trailer)
	46
	47	args = TreeArguments.create_cached(
	48	execution_context.inference_state,
	49	context=context,
	50	argument_node=trailer.children[1],
	51	trailer=trailer,
	52	)
	53	for c in values:
	54	yield c, args
	55
	56
	57	def _goes_to_param_name(param_name, context, potential_name):
	58	if potential_name.type != 'name':
	59	return False
	60	from jedi.inference.names import TreeNameDefinition
	61	found = TreeNameDefinition(context, potential_name).goto()
	62	return any(param_name.parent_context == p.parent_context
	63	and param_name.start_pos == p.start_pos
	64	for p in found)
65
66
67	def _to_callables(context, trailer):
68	from jedi.inference.syntax_tree import infer_trailer
69
70	atom_expr = trailer.parent
71	index = atom_expr.children[0] == 'await'
72	# Infer atom first
73	values = context.infer_node(atom_expr.children[index])
74	for trailer2 in atom_expr.children[index + 1:]:
75	if trailer == trailer2:
76	break
77	values = infer_trailer(context, values, trailer2)
78	return values
79
80
81	def _remove_given_params(arguments, param_names):
82	count = 0
83	used_keys = set()
84	for key, _ in arguments.unpack():
85	if key is None:
86	count += 1
87	else:
88	used_keys.add(key)
89
90	for p in param_names:
91	if count and p.maybe_positional_argument():
92	count -= 1
93	continue
94	if p.string_name in used_keys and p.maybe_keyword_argument():
95	continue
96	yield p
97
98
99	@to_list
100	def process_params(param_names, star_count=3): # default means both * and **
101	if param_names:
102	if is_big_annoying_library(param_names[0].parent_context):
103	# At first this feature can look innocent, but it does a lot of
104	# type inference in some cases, so we just ditch it.
105	yield from param_names
106	return
107
108	used_names = set()
109	arg_callables = []
110	kwarg_callables = []
111
112	kw_only_names = []
113	kwarg_names = []
114	arg_names = []
115	original_arg_name = None
116	original_kwarg_name = None
117	for p in param_names:
118	kind = p.get_kind()
119	if kind == Parameter.VAR_POSITIONAL:
120	if star_count & 1:
121	arg_callables = _iter_nodes_for_param(p)
122	original_arg_name = p
123	elif p.get_kind() == Parameter.VAR_KEYWORD:
124	if star_count & 2:
125	kwarg_callables = list(_iter_nodes_for_param(p))
126	original_kwarg_name = p
127	elif kind == Parameter.KEYWORD_ONLY:
128	if star_count & 2:
129	kw_only_names.append(p)
130	elif kind == Parameter.POSITIONAL_ONLY:
131	if star_count & 1:
132	yield p
133	else:
134	if star_count == 1:
135	yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
136	elif star_count == 2:
137	kw_only_names.append(ParamNameFixedKind(p, Parameter.KEYWORD_ONLY))
138	else:
139	used_names.add(p.string_name)
140	yield p
141
142	# First process *args
143	longest_param_names = ()
144	found_arg_signature = False
145	found_kwarg_signature = False
146	for func_and_argument in arg_callables:
147	func, arguments = func_and_argument
148	new_star_count = star_count
149	if func_and_argument in kwarg_callables:
150	kwarg_callables.remove(func_and_argument)
151	else:
152	new_star_count = 1
153
154	for signature in func.get_signatures():
155	found_arg_signature = True
156	if new_star_count == 3:
157	found_kwarg_signature = True
158	args_for_this_func = []
159	for p in process_params(
160	list(_remove_given_params(
161	arguments,
162	signature.get_param_names(resolve_stars=False)
163	)), new_star_count):
164	if p.get_kind() == Parameter.VAR_KEYWORD:
165	kwarg_names.append(p)
166	elif p.get_kind() == Parameter.VAR_POSITIONAL:
167	arg_names.append(p)
168	elif p.get_kind() == Parameter.KEYWORD_ONLY:
169	kw_only_names.append(p)
170	else:
171	args_for_this_func.append(p)
172	if len(args_for_this_func) > len(longest_param_names):
173	longest_param_names = args_for_this_func
174
175	for p in longest_param_names:
176	if star_count == 1 and p.get_kind() != Parameter.VAR_POSITIONAL:
177	yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
178	else:
179	if p.get_kind() == Parameter.POSITIONAL_OR_KEYWORD:
180	used_names.add(p.string_name)
181	yield p
182
183	if not found_arg_signature and original_arg_name is not None:
184	yield original_arg_name
185	elif arg_names:
186	yield arg_names[0]
187
188	# Then process **kwargs
189	for func, arguments in kwarg_callables:
190	for signature in func.get_signatures():
191	found_kwarg_signature = True
192	for p in process_params(
193	list(_remove_given_params(
194	arguments,
195	signature.get_param_names(resolve_stars=False)
196	)), star_count=2):
197	if p.get_kind() == Parameter.VAR_KEYWORD:
198	kwarg_names.append(p)
199	elif p.get_kind() == Parameter.KEYWORD_ONLY:
200	kw_only_names.append(p)
201
202	for p in kw_only_names:
203	if p.string_name in used_names:
204	continue
205	yield p
206	used_names.add(p.string_name)
207
208	if not found_kwarg_signature and original_kwarg_name is not None:
209	yield original_kwarg_name
210	elif kwarg_names:
211	yield kwarg_names[0]
212
213
214	class ParamNameFixedKind(ParamNameWrapper):
215	def __init__(self, param_name, new_kind):
216	super().__init__(param_name)
217	self._new_kind = new_kind
218
219	def get_kind(self):
220	return self._new_kind