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

from collections import defaultdict
from inspect import Parameter

from jedi import debug
from jedi.inference.utils import PushBackIterator
from jedi.inference import analysis
from jedi.inference.lazy_value import LazyKnownValue, \
    LazyTreeValue, LazyUnknownValue
from jedi.inference.value import iterable
from jedi.inference.names import ParamName


def _add_argument_issue(error_name, lazy_value, message):
    if isinstance(lazy_value, LazyTreeValue):
        node = lazy_value.data
        if node.parent.type == 'argument':
            node = node.parent
        return analysis.add(lazy_value.context, error_name, node, message)


class ExecutedParamName(ParamName):
    def __init__(self, function_value, arguments, param_node, lazy_value, is_default=False):
        super().__init__(function_value, param_node.name, arguments=arguments)
        self._lazy_value = lazy_value
        self._is_default = is_default

    def infer(self):
        return self._lazy_value.infer()

    def matches_signature(self):
        if self._is_default:
            return True
        argument_values = self.infer().py__class__()
        if self.get_kind() in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
            return True
        annotations = self.infer_annotation(execute_annotation=False)
        if not annotations:
            # If we cannot infer annotations - or there aren't any - pretend
            # that the signature matches.
            return True
        matches = any(c1.is_sub_class_of(c2)
                      for c1 in argument_values
                      for c2 in annotations.gather_annotation_classes())
        debug.dbg("param compare %s: %s <=> %s",
                  matches, argument_values, annotations, color='BLUE')
        return matches

    def __repr__(self):
        return '<%s: %s>' % (self.__class__.__name__, self.string_name)


def get_executed_param_names_and_issues(function_value, arguments):
    """
    Return a tuple of:
      - a list of `ExecutedParamName`s corresponding to the arguments of the
        function execution `function_value`, containing the inferred value of
        those arguments (whether explicit or default)
      - a list of the issues encountered while building that list

    For example, given:
    ```
    def foo(a, b, c=None, d='d'): ...

    foo(42, c='c')
    ```

    Then for the execution of `foo`, this will return a tuple containing:
      - a list with entries for each parameter a, b, c & d; the entries for a,
        c, & d will have their values (42, 'c' and 'd' respectively) included.
      - a list with a single entry about the lack of a value for `b`
    """
    def too_many_args(argument):
        m = _error_argument_count(funcdef, len(unpacked_va))
        # Just report an error for the first param that is not needed (like
        # cPython).
        if arguments.get_calling_nodes():
            # There might not be a valid calling node so check for that first.
            issues.append(
                _add_argument_issue(
                    'type-error-too-many-arguments',
                    argument,
                    message=m
                )
            )
        else:
            issues.append(None)
            debug.warning('non-public warning: %s', m)

    issues = []  # List[Optional[analysis issue]]
    result_params = []
    param_dict = {}
    funcdef = function_value.tree_node
    # Default params are part of the value where the function was defined.
    # This means that they might have access on class variables that the
    # function itself doesn't have.
    default_param_context = function_value.get_default_param_context()

    for param in funcdef.get_params():
        param_dict[param.name.value] = param
    unpacked_va = list(arguments.unpack(funcdef))
    var_arg_iterator = PushBackIterator(iter(unpacked_va))

    non_matching_keys = defaultdict(lambda: [])
    keys_used = {}
    keys_only = False
    had_multiple_value_error = False
    for param in funcdef.get_params():
        # The value and key can both be null. There, the defaults apply.
        # args / kwargs will just be empty arrays / dicts, respectively.
        # Wrong value count is just ignored. If you try to test cases that are
        # not allowed in Python, Jedi will maybe not show any completions.
        is_default = False
        key, argument = next(var_arg_iterator, (None, None))
        while key is not None:
            keys_only = True
            try:
                key_param = param_dict[key]
            except KeyError:
                non_matching_keys[key] = argument
            else:
                if key in keys_used:
                    had_multiple_value_error = True
                    m = ("TypeError: %s() got multiple values for keyword argument '%s'."
                         % (funcdef.name, key))
                    for contextualized_node in arguments.get_calling_nodes():
                        issues.append(
                            analysis.add(contextualized_node.context,
                                         'type-error-multiple-values',
                                         contextualized_node.node, message=m)
                        )
                else:
                    keys_used[key] = ExecutedParamName(
                        function_value, arguments, key_param, argument)
            key, argument = next(var_arg_iterator, (None, None))

        try:
            result_params.append(keys_used[param.name.value])
            continue
        except KeyError:
            pass

        if param.star_count == 1:
            # *args param
            lazy_value_list = []
            if argument is not None:
                lazy_value_list.append(argument)
                for key, argument in var_arg_iterator:
                    # Iterate until a key argument is found.
                    if key:
                        var_arg_iterator.push_back((key, argument))
                        break
                    lazy_value_list.append(argument)
            seq = iterable.FakeTuple(function_value.inference_state, lazy_value_list)
            result_arg = LazyKnownValue(seq)
        elif param.star_count == 2:
            if argument is not None:
                too_many_args(argument)
            # **kwargs param
            dct = iterable.FakeDict(function_value.inference_state, dict(non_matching_keys))
            result_arg = LazyKnownValue(dct)
            non_matching_keys = {}
        else:
            # normal param
            if argument is None:
                # No value: Return an empty container
                if param.default is None:
                    result_arg = LazyUnknownValue()
                    if not keys_only:
                        for contextualized_node in arguments.get_calling_nodes():
                            m = _error_argument_count(funcdef, len(unpacked_va))
                            issues.append(
                                analysis.add(
                                    contextualized_node.context,
                                    'type-error-too-few-arguments',
                                    contextualized_node.node,
                                    message=m,
                                )
                            )
                else:
                    result_arg = LazyTreeValue(default_param_context, param.default)
                    is_default = True
            else:
                result_arg = argument

        result_params.append(ExecutedParamName(
            function_value, arguments, param, result_arg, is_default=is_default
        ))
        if not isinstance(result_arg, LazyUnknownValue):
            keys_used[param.name.value] = result_params[-1]

    if keys_only:
        # All arguments should be handed over to the next function. It's not
        # about the values inside, it's about the names. Jedi needs to now that
        # there's nothing to find for certain names.
        for k in set(param_dict) - set(keys_used):
            param = param_dict[k]

            if not (non_matching_keys or had_multiple_value_error
                    or param.star_count or param.default):
                # add a warning only if there's not another one.
                for contextualized_node in arguments.get_calling_nodes():
                    m = _error_argument_count(funcdef, len(unpacked_va))
                    issues.append(
                        analysis.add(contextualized_node.context,
                                     'type-error-too-few-arguments',
                                     contextualized_node.node, message=m)
                    )

    for key, lazy_value in non_matching_keys.items():
        m = "TypeError: %s() got an unexpected keyword argument '%s'." \
            % (funcdef.name, key)
        issues.append(
            _add_argument_issue(
                'type-error-keyword-argument',
                lazy_value,
                message=m
            )
        )

    remaining_arguments = list(var_arg_iterator)
    if remaining_arguments:
        first_key, lazy_value = remaining_arguments[0]
        too_many_args(lazy_value)
    return result_params, issues


def get_executed_param_names(function_value, arguments):
    """
    Return a list of `ExecutedParamName`s corresponding to the arguments of the
    function execution `function_value`, containing the inferred value of those
    arguments (whether explicit or default). Any issues building this list (for
    example required arguments which are missing in the invocation) are ignored.

    For example, given:
    ```
    def foo(a, b, c=None, d='d'): ...

    foo(42, c='c')
    ```

    Then for the execution of `foo`, this will return a list containing entries
    for each parameter a, b, c & d; the entries for a, c, & d will have their
    values (42, 'c' and 'd' respectively) included.
    """
    return get_executed_param_names_and_issues(function_value, arguments)[0]


def _error_argument_count(funcdef, actual_count):
    params = funcdef.get_params()
    default_arguments = sum(1 for p in params if p.default or p.star_count)

    if default_arguments == 0:
        before = 'exactly '
    else:
        before = 'from %s to ' % (len(params) - default_arguments)
    return ('TypeError: %s() takes %s%s arguments (%s given).'
            % (funcdef.name, before, len(params), actual_count))
Commit	Line	Data
53e6db90 DC	1	from collections import defaultdict
	2	from inspect import Parameter
	3
	4	from jedi import debug
	5	from jedi.inference.utils import PushBackIterator
	6	from jedi.inference import analysis
	7	from jedi.inference.lazy_value import LazyKnownValue, \
	8	LazyTreeValue, LazyUnknownValue
	9	from jedi.inference.value import iterable
	10	from jedi.inference.names import ParamName
	11
	12
	13	def _add_argument_issue(error_name, lazy_value, message):
	14	if isinstance(lazy_value, LazyTreeValue):
	15	node = lazy_value.data
	16	if node.parent.type == 'argument':
	17	node = node.parent
	18	return analysis.add(lazy_value.context, error_name, node, message)
	19
	20
	21	class ExecutedParamName(ParamName):
	22	def __init__(self, function_value, arguments, param_node, lazy_value, is_default=False):
	23	super().__init__(function_value, param_node.name, arguments=arguments)
	24	self._lazy_value = lazy_value
	25	self._is_default = is_default
	26
	27	def infer(self):
	28	return self._lazy_value.infer()
	29
	30	def matches_signature(self):
	31	if self._is_default:
	32	return True
	33	argument_values = self.infer().py__class__()
	34	if self.get_kind() in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
	35	return True
	36	annotations = self.infer_annotation(execute_annotation=False)
	37	if not annotations:
	38	# If we cannot infer annotations - or there aren't any - pretend
	39	# that the signature matches.
	40	return True
	41	matches = any(c1.is_sub_class_of(c2)
	42	for c1 in argument_values
	43	for c2 in annotations.gather_annotation_classes())
	44	debug.dbg("param compare %s: %s <=> %s",
	45	matches, argument_values, annotations, color='BLUE')
	46	return matches
	47
	48	def __repr__(self):
	49	return '<%s: %s>' % (self.__class__.__name__, self.string_name)
	50
	51
	52	def get_executed_param_names_and_issues(function_value, arguments):
	53	"""
	54	Return a tuple of:
	55	- a list of `ExecutedParamName`s corresponding to the arguments of the
	56	function execution `function_value`, containing the inferred value of
	57	those arguments (whether explicit or default)
	58	- a list of the issues encountered while building that list
	59
	60	For example, given:
	61	```
	62	def foo(a, b, c=None, d='d'): ...
	63
	64	foo(42, c='c')
65	```
66
67	Then for the execution of `foo`, this will return a tuple containing:
68	- a list with entries for each parameter a, b, c & d; the entries for a,
69	c, & d will have their values (42, 'c' and 'd' respectively) included.
70	- a list with a single entry about the lack of a value for `b`
71	"""
72	def too_many_args(argument):
73	m = _error_argument_count(funcdef, len(unpacked_va))
74	# Just report an error for the first param that is not needed (like
75	# cPython).
76	if arguments.get_calling_nodes():
77	# There might not be a valid calling node so check for that first.
78	issues.append(
79	_add_argument_issue(
80	'type-error-too-many-arguments',
81	argument,
82	message=m
83	)
84	)
85	else:
86	issues.append(None)
87	debug.warning('non-public warning: %s', m)
88
89	issues = [] # List[Optional[analysis issue]]
90	result_params = []
91	param_dict = {}
92	funcdef = function_value.tree_node
93	# Default params are part of the value where the function was defined.
94	# This means that they might have access on class variables that the
95	# function itself doesn't have.
96	default_param_context = function_value.get_default_param_context()
97
98	for param in funcdef.get_params():
99	param_dict[param.name.value] = param
100	unpacked_va = list(arguments.unpack(funcdef))
101	var_arg_iterator = PushBackIterator(iter(unpacked_va))
102
103	non_matching_keys = defaultdict(lambda: [])
104	keys_used = {}
105	keys_only = False
106	had_multiple_value_error = False
107	for param in funcdef.get_params():
108	# The value and key can both be null. There, the defaults apply.
109	# args / kwargs will just be empty arrays / dicts, respectively.
110	# Wrong value count is just ignored. If you try to test cases that are
111	# not allowed in Python, Jedi will maybe not show any completions.
112	is_default = False
113	key, argument = next(var_arg_iterator, (None, None))
114	while key is not None:
115	keys_only = True
116	try:
117	key_param = param_dict[key]
118	except KeyError:
119	non_matching_keys[key] = argument
120	else:
121	if key in keys_used:
122	had_multiple_value_error = True
123	m = ("TypeError: %s() got multiple values for keyword argument '%s'."
124	% (funcdef.name, key))
125	for contextualized_node in arguments.get_calling_nodes():
126	issues.append(
127	analysis.add(contextualized_node.context,
128	'type-error-multiple-values',
129	contextualized_node.node, message=m)
130	)
131	else:
132	keys_used[key] = ExecutedParamName(
133	function_value, arguments, key_param, argument)
134	key, argument = next(var_arg_iterator, (None, None))
135
136	try:
137	result_params.append(keys_used[param.name.value])
138	continue
139	except KeyError:
140	pass
141
142	if param.star_count == 1:
143	# *args param
144	lazy_value_list = []
145	if argument is not None:
146	lazy_value_list.append(argument)
147	for key, argument in var_arg_iterator:
148	# Iterate until a key argument is found.
149	if key:
150	var_arg_iterator.push_back((key, argument))
151	break
152	lazy_value_list.append(argument)
153	seq = iterable.FakeTuple(function_value.inference_state, lazy_value_list)
154	result_arg = LazyKnownValue(seq)
155	elif param.star_count == 2:
156	if argument is not None:
157	too_many_args(argument)
158	# **kwargs param
159	dct = iterable.FakeDict(function_value.inference_state, dict(non_matching_keys))
160	result_arg = LazyKnownValue(dct)
161	non_matching_keys = {}
162	else:
163	# normal param
164	if argument is None:
165	# No value: Return an empty container
166	if param.default is None:
167	result_arg = LazyUnknownValue()
168	if not keys_only:
169	for contextualized_node in arguments.get_calling_nodes():
170	m = _error_argument_count(funcdef, len(unpacked_va))
171	issues.append(
172	analysis.add(
173	contextualized_node.context,
174	'type-error-too-few-arguments',
175	contextualized_node.node,
176	message=m,
177	)
178	)
179	else:
180	result_arg = LazyTreeValue(default_param_context, param.default)
181	is_default = True
182	else:
183	result_arg = argument
184
185	result_params.append(ExecutedParamName(
186	function_value, arguments, param, result_arg, is_default=is_default
187	))
188	if not isinstance(result_arg, LazyUnknownValue):
189	keys_used[param.name.value] = result_params[-1]
190
191	if keys_only:
192	# All arguments should be handed over to the next function. It's not
193	# about the values inside, it's about the names. Jedi needs to now that
194	# there's nothing to find for certain names.
195	for k in set(param_dict) - set(keys_used):
196	param = param_dict[k]
197
198	if not (non_matching_keys or had_multiple_value_error
199	or param.star_count or param.default):
200	# add a warning only if there's not another one.
201	for contextualized_node in arguments.get_calling_nodes():
202	m = _error_argument_count(funcdef, len(unpacked_va))
203	issues.append(
204	analysis.add(contextualized_node.context,
205	'type-error-too-few-arguments',
206	contextualized_node.node, message=m)
207	)
208
209	for key, lazy_value in non_matching_keys.items():
210	m = "TypeError: %s() got an unexpected keyword argument '%s'." \
211	% (funcdef.name, key)
212	issues.append(
213	_add_argument_issue(
214	'type-error-keyword-argument',
215	lazy_value,
216	message=m
217	)
218	)
219
220	remaining_arguments = list(var_arg_iterator)
221	if remaining_arguments:
222	first_key, lazy_value = remaining_arguments[0]
223	too_many_args(lazy_value)
224	return result_params, issues
225
226
227	def get_executed_param_names(function_value, arguments):
228	"""
229	Return a list of `ExecutedParamName`s corresponding to the arguments of the
230	function execution `function_value`, containing the inferred value of those
231	arguments (whether explicit or default). Any issues building this list (for
232	example required arguments which are missing in the invocation) are ignored.
233
234	For example, given:
235	```
236	def foo(a, b, c=None, d='d'): ...
237
238	foo(42, c='c')
239	```
240
241	Then for the execution of `foo`, this will return a list containing entries
242	for each parameter a, b, c & d; the entries for a, c, & d will have their
243	values (42, 'c' and 'd' respectively) included.
244	"""
245	return get_executed_param_names_and_issues(function_value, arguments)[0]
246
247
248	def _error_argument_count(funcdef, actual_count):
249	params = funcdef.get_params()
250	default_arguments = sum(1 for p in params if p.default or p.star_count)
251
252	if default_arguments == 0:
253	before = 'exactly '
254	else:
255	before = 'from %s to ' % (len(params) - default_arguments)
256	return ('TypeError: %s() takes %s%s arguments (%s given).'
257	% (funcdef.name, before, len(params), actual_count))