djavu-asus/elpy/rpc-venv/lib/python3.11/site-packages/jedi/inference/value/instance.py

   1 from abc import abstractproperty
   2
   3 from parso.tree import search_ancestor
   4
   5 from jedi import debug
   6 from jedi import settings
   7 from jedi.inference import compiled
   8 from jedi.inference.compiled.value import CompiledValueFilter
   9 from jedi.inference.helpers import values_from_qualified_names, is_big_annoying_library
  10 from jedi.inference.filters import AbstractFilter, AnonymousFunctionExecutionFilter
  11 from jedi.inference.names import ValueName, TreeNameDefinition, ParamName, \
  12     NameWrapper
  13 from jedi.inference.base_value import Value, NO_VALUES, ValueSet, \
  14     iterator_to_value_set, ValueWrapper
  15 from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues
  16 from jedi.inference.cache import inference_state_method_cache
  17 from jedi.inference.arguments import ValuesArguments, TreeArgumentsWrapper
  18 from jedi.inference.value.function import \
  19     FunctionValue, FunctionMixin, OverloadedFunctionValue, \
  20     BaseFunctionExecutionContext, FunctionExecutionContext, FunctionNameInClass
  21 from jedi.inference.value.klass import ClassFilter
  22 from jedi.inference.value.dynamic_arrays import get_dynamic_array_instance
  23 from jedi.parser_utils import function_is_staticmethod, function_is_classmethod
  24
  25
  26 class InstanceExecutedParamName(ParamName):
  27     def __init__(self, instance, function_value, tree_name):
  28         super().__init__(
  29             function_value, tree_name, arguments=None)
  30         self._instance = instance
  31
  32     def infer(self):
  33         return ValueSet([self._instance])
  34
  35     def matches_signature(self):
  36         return True
  37
  38
  39 class AnonymousMethodExecutionFilter(AnonymousFunctionExecutionFilter):
  40     def __init__(self, instance, *args, **kwargs):
  41         super().__init__(*args, **kwargs)
  42         self._instance = instance
  43
  44     def _convert_param(self, param, name):
  45         if param.position_index == 0:
  46             if function_is_classmethod(self._function_value.tree_node):
  47                 return InstanceExecutedParamName(
  48                     self._instance.py__class__(),
  49                     self._function_value,
  50                     name
  51                 )
  52             elif not function_is_staticmethod(self._function_value.tree_node):
  53                 return InstanceExecutedParamName(
  54                     self._instance,
  55                     self._function_value,
  56                     name
  57                 )
  58         return super()._convert_param(param, name)
  59
  60
  61 class AnonymousMethodExecutionContext(BaseFunctionExecutionContext):
  62     def __init__(self, instance, value):
  63         super().__init__(value)
  64         self.instance = instance
  65
  66     def get_filters(self, until_position=None, origin_scope=None):
  67         yield AnonymousMethodExecutionFilter(
  68             self.instance, self, self._value,
  69             until_position=until_position,
  70             origin_scope=origin_scope,
  71         )
  72
  73     def get_param_names(self):
  74         param_names = list(self._value.get_param_names())
  75         # set the self name
  76         param_names[0] = InstanceExecutedParamName(
  77             self.instance,
  78             self._value,
  79             param_names[0].tree_name
  80         )
  81         return param_names
  82
  83
  84 class MethodExecutionContext(FunctionExecutionContext):
  85     def __init__(self, instance, *args, **kwargs):
  86         super().__init__(*args, **kwargs)
  87         self.instance = instance
  88
  89
  90 class AbstractInstanceValue(Value):
  91     api_type = 'instance'
  92
  93     def __init__(self, inference_state, parent_context, class_value):
  94         super().__init__(inference_state, parent_context)
  95         # Generated instances are classes that are just generated by self
  96         # (No arguments) used.
  97         self.class_value = class_value
  98
  99     def is_instance(self):
 100         return True
 101
 102     def get_qualified_names(self):
 103         return self.class_value.get_qualified_names()
 104
 105     def get_annotated_class_object(self):
 106         return self.class_value  # This is the default.
 107
 108     def py__class__(self):
 109         return self.class_value
 110
 111     def py__bool__(self):
 112         # Signalize that we don't know about the bool type.
 113         return None
 114
 115     @abstractproperty
 116     def name(self):
 117         raise NotImplementedError
 118
 119     def get_signatures(self):
 120         call_funcs = self.py__getattribute__('__call__').py__get__(self, self.class_value)
 121         return [s.bind(self) for s in call_funcs.get_signatures()]
 122
 123     def get_function_slot_names(self, name):
 124         # Python classes don't look at the dictionary of the instance when
 125         # looking up `__call__`. This is something that has to do with Python's
 126         # internal slot system (note: not __slots__, but C slots).
 127         for filter in self.get_filters(include_self_names=False):
 128             names = filter.get(name)
 129             if names:
 130                 return names
 131         return []
 132
 133     def execute_function_slots(self, names, *inferred_args):
 134         return ValueSet.from_sets(
 135             name.infer().execute_with_values(*inferred_args)
 136             for name in names
 137         )
 138
 139     def get_type_hint(self, add_class_info=True):
 140         return self.py__name__()
 141
 142     def py__getitem__(self, index_value_set, contextualized_node):
 143         names = self.get_function_slot_names('__getitem__')
 144         if not names:
 145             return super().py__getitem__(
 146                 index_value_set,
 147                 contextualized_node,
 148             )
 149
 150         args = ValuesArguments([index_value_set])
 151         return ValueSet.from_sets(name.infer().execute(args) for name in names)
 152
 153     def py__iter__(self, contextualized_node=None):
 154         iter_slot_names = self.get_function_slot_names('__iter__')
 155         if not iter_slot_names:
 156             return super().py__iter__(contextualized_node)
 157
 158         def iterate():
 159             for generator in self.execute_function_slots(iter_slot_names):
 160                 yield from generator.py__next__(contextualized_node)
 161         return iterate()
 162
 163     def __repr__(self):
 164         return "<%s of %s>" % (self.__class__.__name__, self.class_value)
 165
 166
 167 class CompiledInstance(AbstractInstanceValue):
 168     # This is not really a compiled class, it's just an instance from a
 169     # compiled class.
 170     def __init__(self, inference_state, parent_context, class_value, arguments):
 171         super().__init__(inference_state, parent_context, class_value)
 172         self._arguments = arguments
 173
 174     def get_filters(self, origin_scope=None, include_self_names=True):
 175         class_value = self.get_annotated_class_object()
 176         class_filters = class_value.get_filters(
 177             origin_scope=origin_scope,
 178             is_instance=True,
 179         )
 180         for f in class_filters:
 181             yield CompiledInstanceClassFilter(self, f)
 182
 183     @property
 184     def name(self):
 185         return compiled.CompiledValueName(self, self.class_value.name.string_name)
 186
 187     def is_stub(self):
 188         return False
 189
 190
 191 class _BaseTreeInstance(AbstractInstanceValue):
 192     @property
 193     def array_type(self):
 194         name = self.class_value.py__name__()
 195         if name in ['list', 'set', 'dict'] \
 196                 and self.parent_context.get_root_context().is_builtins_module():
 197             return name
 198         return None
 199
 200     @property
 201     def name(self):
 202         return ValueName(self, self.class_value.name.tree_name)
 203
 204     def get_filters(self, origin_scope=None, include_self_names=True):
 205         class_value = self.get_annotated_class_object()
 206         if include_self_names:
 207             for cls in class_value.py__mro__():
 208                 if not cls.is_compiled():
 209                     # In this case we're excluding compiled objects that are
 210                     # not fake objects. It doesn't make sense for normal
 211                     # compiled objects to search for self variables.
 212                     yield SelfAttributeFilter(self, class_value, cls.as_context(), origin_scope)
 213
 214         class_filters = class_value.get_filters(
 215             origin_scope=origin_scope,
 216             is_instance=True,
 217         )
 218         for f in class_filters:
 219             if isinstance(f, ClassFilter):
 220                 yield InstanceClassFilter(self, f)
 221             elif isinstance(f, CompiledValueFilter):
 222                 yield CompiledInstanceClassFilter(self, f)
 223             else:
 224                 # Propably from the metaclass.
 225                 yield f
 226
 227     @inference_state_method_cache()
 228     def create_instance_context(self, class_context, node):
 229         new = node
 230         while True:
 231             func_node = new
 232             new = search_ancestor(new, 'funcdef', 'classdef')
 233             if class_context.tree_node is new:
 234                 func = FunctionValue.from_context(class_context, func_node)
 235                 bound_method = BoundMethod(self, class_context, func)
 236                 if func_node.name.value == '__init__':
 237                     context = bound_method.as_context(self._arguments)
 238                 else:
 239                     context = bound_method.as_context()
 240                 break
 241         return context.create_context(node)
 242
 243     def py__getattribute__alternatives(self, string_name):
 244         '''
 245         Since nothing was inferred, now check the __getattr__ and
 246         __getattribute__ methods. Stubs don't need to be checked, because
 247         they don't contain any logic.
 248         '''
 249         if self.is_stub():
 250             return NO_VALUES
 251
 252         name = compiled.create_simple_object(self.inference_state, string_name)
 253
 254         # This is a little bit special. `__getattribute__` is in Python
 255         # executed before `__getattr__`. But: I know no use case, where
 256         # this could be practical and where Jedi would return wrong types.
 257         # If you ever find something, let me know!
 258         # We are inversing this, because a hand-crafted `__getattribute__`
 259         # could still call another hand-crafted `__getattr__`, but not the
 260         # other way around.
 261         if is_big_annoying_library(self.parent_context):
 262             return NO_VALUES
 263         names = (self.get_function_slot_names('__getattr__')
 264                  or self.get_function_slot_names('__getattribute__'))
 265         return self.execute_function_slots(names, name)
 266
 267     def py__next__(self, contextualized_node=None):
 268         name = u'__next__'
 269         next_slot_names = self.get_function_slot_names(name)
 270         if next_slot_names:
 271             yield LazyKnownValues(
 272                 self.execute_function_slots(next_slot_names)
 273             )
 274         else:
 275             debug.warning('Instance has no __next__ function in %s.', self)
 276
 277     def py__call__(self, arguments):
 278         names = self.get_function_slot_names('__call__')
 279         if not names:
 280             # Means the Instance is not callable.
 281             return super().py__call__(arguments)
 282
 283         return ValueSet.from_sets(name.infer().execute(arguments) for name in names)
 284
 285     def py__get__(self, instance, class_value):
 286         """
 287         obj may be None.
 288         """
 289         # Arguments in __get__ descriptors are obj, class.
 290         # `method` is the new parent of the array, don't know if that's good.
 291         for cls in self.class_value.py__mro__():
 292             result = cls.py__get__on_class(self, instance, class_value)
 293             if result is not NotImplemented:
 294                 return result
 295
 296         names = self.get_function_slot_names('__get__')
 297         if names:
 298             if instance is None:
 299                 instance = compiled.builtin_from_name(self.inference_state, 'None')
 300             return self.execute_function_slots(names, instance, class_value)
 301         else:
 302             return ValueSet([self])
 303
 304
 305 class TreeInstance(_BaseTreeInstance):
 306     def __init__(self, inference_state, parent_context, class_value, arguments):
 307         # I don't think that dynamic append lookups should happen here. That
 308         # sounds more like something that should go to py__iter__.
 309         if class_value.py__name__() in ['list', 'set'] \
 310                 and parent_context.get_root_context().is_builtins_module():
 311             # compare the module path with the builtin name.
 312             if settings.dynamic_array_additions:
 313                 arguments = get_dynamic_array_instance(self, arguments)
 314
 315         super().__init__(inference_state, parent_context, class_value)
 316         self._arguments = arguments
 317         self.tree_node = class_value.tree_node
 318
 319     # This can recurse, if the initialization of the class includes a reference
 320     # to itself.
 321     @inference_state_method_cache(default=None)
 322     def _get_annotated_class_object(self):
 323         from jedi.inference.gradual.annotation import py__annotations__, \
 324             infer_type_vars_for_execution
 325
 326         args = InstanceArguments(self, self._arguments)
 327         for signature in self.class_value.py__getattribute__('__init__').get_signatures():
 328             # Just take the first result, it should always be one, because we
 329             # control the typeshed code.
 330             funcdef = signature.value.tree_node
 331             if funcdef is None or funcdef.type != 'funcdef' \
 332                     or not signature.matches_signature(args):
 333                 # First check if the signature even matches, if not we don't
 334                 # need to infer anything.
 335                 continue
 336             bound_method = BoundMethod(self, self.class_value.as_context(), signature.value)
 337             all_annotations = py__annotations__(funcdef)
 338             type_var_dict = infer_type_vars_for_execution(bound_method, args, all_annotations)
 339             if type_var_dict:
 340                 defined, = self.class_value.define_generics(
 341                     infer_type_vars_for_execution(signature.value, args, all_annotations),
 342                 )
 343                 debug.dbg('Inferred instance value as %s', defined, color='BLUE')
 344                 return defined
 345         return None
 346
 347     def get_annotated_class_object(self):
 348         return self._get_annotated_class_object() or self.class_value
 349
 350     def get_key_values(self):
 351         values = NO_VALUES
 352         if self.array_type == 'dict':
 353             for i, (key, instance) in enumerate(self._arguments.unpack()):
 354                 if key is None and i == 0:
 355                     values |= ValueSet.from_sets(
 356                         v.get_key_values()
 357                         for v in instance.infer()
 358                         if v.array_type == 'dict'
 359                     )
 360                 if key:
 361                     values |= ValueSet([compiled.create_simple_object(
 362                         self.inference_state,
 363                         key,
 364                     )])
 365
 366         return values
 367
 368     def py__simple_getitem__(self, index):
 369         if self.array_type == 'dict':
 370             # Logic for dict({'foo': bar}) and dict(foo=bar)
 371             # reversed, because:
 372             # >>> dict({'a': 1}, a=3)
 373             # {'a': 3}
 374             # TODO tuple initializations
 375             # >>> dict([('a', 4)])
 376             # {'a': 4}
 377             for key, lazy_context in reversed(list(self._arguments.unpack())):
 378                 if key is None:
 379                     values = ValueSet.from_sets(
 380                         dct_value.py__simple_getitem__(index)
 381                         for dct_value in lazy_context.infer()
 382                         if dct_value.array_type == 'dict'
 383                     )
 384                     if values:
 385                         return values
 386                 else:
 387                     if key == index:
 388                         return lazy_context.infer()
 389         return super().py__simple_getitem__(index)
 390
 391     def __repr__(self):
 392         return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_value,
 393                                    self._arguments)
 394
 395
 396 class AnonymousInstance(_BaseTreeInstance):
 397     _arguments = None
 398
 399
 400 class CompiledInstanceName(NameWrapper):
 401     @iterator_to_value_set
 402     def infer(self):
 403         for result_value in self._wrapped_name.infer():
 404             if result_value.api_type == 'function':
 405                 yield CompiledBoundMethod(result_value)
 406             else:
 407                 yield result_value
 408
 409
 410 class CompiledInstanceClassFilter(AbstractFilter):
 411     def __init__(self, instance, f):
 412         self._instance = instance
 413         self._class_filter = f
 414
 415     def get(self, name):
 416         return self._convert(self._class_filter.get(name))
 417
 418     def values(self):
 419         return self._convert(self._class_filter.values())
 420
 421     def _convert(self, names):
 422         return [CompiledInstanceName(n) for n in names]
 423
 424
 425 class BoundMethod(FunctionMixin, ValueWrapper):
 426     def __init__(self, instance, class_context, function):
 427         super().__init__(function)
 428         self.instance = instance
 429         self._class_context = class_context
 430
 431     def is_bound_method(self):
 432         return True
 433
 434     @property
 435     def name(self):
 436         return FunctionNameInClass(
 437             self._class_context,
 438             super().name
 439         )
 440
 441     def py__class__(self):
 442         c, = values_from_qualified_names(self.inference_state, 'types', 'MethodType')
 443         return c
 444
 445     def _get_arguments(self, arguments):
 446         assert arguments is not None
 447         return InstanceArguments(self.instance, arguments)
 448
 449     def _as_context(self, arguments=None):
 450         if arguments is None:
 451             return AnonymousMethodExecutionContext(self.instance, self)
 452
 453         arguments = self._get_arguments(arguments)
 454         return MethodExecutionContext(self.instance, self, arguments)
 455
 456     def py__call__(self, arguments):
 457         if isinstance(self._wrapped_value, OverloadedFunctionValue):
 458             return self._wrapped_value.py__call__(self._get_arguments(arguments))
 459
 460         function_execution = self.as_context(arguments)
 461         return function_execution.infer()
 462
 463     def get_signature_functions(self):
 464         return [
 465             BoundMethod(self.instance, self._class_context, f)
 466             for f in self._wrapped_value.get_signature_functions()
 467         ]
 468
 469     def get_signatures(self):
 470         return [sig.bind(self) for sig in super().get_signatures()]
 471
 472     def __repr__(self):
 473         return '<%s: %s>' % (self.__class__.__name__, self._wrapped_value)
 474
 475
 476 class CompiledBoundMethod(ValueWrapper):
 477     def is_bound_method(self):
 478         return True
 479
 480     def get_signatures(self):
 481         return [sig.bind(self) for sig in self._wrapped_value.get_signatures()]
 482
 483
 484 class SelfName(TreeNameDefinition):
 485     """
 486     This name calculates the parent_context lazily.
 487     """
 488     def __init__(self, instance, class_context, tree_name):
 489         self._instance = instance
 490         self.class_context = class_context
 491         self.tree_name = tree_name
 492
 493     @property
 494     def parent_context(self):
 495         return self._instance.create_instance_context(self.class_context, self.tree_name)
 496
 497     def get_defining_qualified_value(self):
 498         return self._instance
 499
 500     def infer(self):
 501         stmt = search_ancestor(self.tree_name, 'expr_stmt')
 502         if stmt is not None:
 503             if stmt.children[1].type == "annassign":
 504                 from jedi.inference.gradual.annotation import infer_annotation
 505                 values = infer_annotation(
 506                     self.parent_context, stmt.children[1].children[1]
 507                 ).execute_annotation()
 508                 if values:
 509                     return values
 510         return super().infer()
 511
 512
 513 class LazyInstanceClassName(NameWrapper):
 514     def __init__(self, instance, class_member_name):
 515         super().__init__(class_member_name)
 516         self._instance = instance
 517
 518     @iterator_to_value_set
 519     def infer(self):
 520         for result_value in self._wrapped_name.infer():
 521             yield from result_value.py__get__(self._instance, self._instance.py__class__())
 522
 523     def get_signatures(self):
 524         return self.infer().get_signatures()
 525
 526     def get_defining_qualified_value(self):
 527         return self._instance
 528
 529
 530 class InstanceClassFilter(AbstractFilter):
 531     """
 532     This filter is special in that it uses the class filter and wraps the
 533     resulting names in LazyInstanceClassName. The idea is that the class name
 534     filtering can be very flexible and always be reflected in instances.
 535     """
 536     def __init__(self, instance, class_filter):
 537         self._instance = instance
 538         self._class_filter = class_filter
 539
 540     def get(self, name):
 541         return self._convert(self._class_filter.get(name))
 542
 543     def values(self):
 544         return self._convert(self._class_filter.values())
 545
 546     def _convert(self, names):
 547         return [
 548             LazyInstanceClassName(self._instance, n)
 549             for n in names
 550         ]
 551
 552     def __repr__(self):
 553         return '<%s for %s>' % (self.__class__.__name__, self._class_filter)
 554
 555
 556 class SelfAttributeFilter(ClassFilter):
 557     """
 558     This class basically filters all the use cases where `self.*` was assigned.
 559     """
 560     def __init__(self, instance, instance_class, node_context, origin_scope):
 561         super().__init__(
 562             class_value=instance_class,
 563             node_context=node_context,
 564             origin_scope=origin_scope,
 565             is_instance=True,
 566         )
 567         self._instance = instance
 568
 569     def _filter(self, names):
 570         start, end = self._parser_scope.start_pos, self._parser_scope.end_pos
 571         names = [n for n in names if start < n.start_pos < end]
 572         return self._filter_self_names(names)
 573
 574     def _filter_self_names(self, names):
 575         for name in names:
 576             trailer = name.parent
 577             if trailer.type == 'trailer' \
 578                     and len(trailer.parent.children) == 2 \
 579                     and trailer.children[0] == '.':
 580                 if name.is_definition() and self._access_possible(name):
 581                     # TODO filter non-self assignments instead of this bad
 582                     #      filter.
 583                     if self._is_in_right_scope(trailer.parent.children[0], name):
 584                         yield name
 585
 586     def _is_in_right_scope(self, self_name, name):
 587         self_context = self._node_context.create_context(self_name)
 588         names = self_context.goto(self_name, position=self_name.start_pos)
 589         return any(
 590             n.api_type == 'param'
 591             and n.tree_name.get_definition().position_index == 0
 592             and n.parent_context.tree_node is self._parser_scope
 593             for n in names
 594         )
 595
 596     def _convert_names(self, names):
 597         return [SelfName(self._instance, self._node_context, name) for name in names]
 598
 599     def _check_flows(self, names):
 600         return names
 601
 602
 603 class InstanceArguments(TreeArgumentsWrapper):
 604     def __init__(self, instance, arguments):
 605         super().__init__(arguments)
 606         self.instance = instance
 607
 608     def unpack(self, func=None):
 609         yield None, LazyKnownValue(self.instance)
 610         yield from self._wrapped_arguments.unpack(func)