1  from abc import abstractmethod
   2  from contextlib import contextmanager
   3  from pathlib import Path
   4  from typing import Optional
   5  
   6  from parso.tree import search_ancestor
   7  from parso.python.tree import Name
   8  
   9  from jedi.inference.filters import ParserTreeFilter, MergedFilter, \
  10      GlobalNameFilter
  11  from jedi.inference.names import AnonymousParamName, TreeNameDefinition
  12  from jedi.inference.base_value import NO_VALUES, ValueSet
  13  from jedi.parser_utils import get_parent_scope
  14  from jedi import debug
  15  from jedi import parser_utils
  16  
  17  
  18  class AbstractContext:
  19      # Must be defined: inference_state and tree_node and parent_context as an attribute/property
  20  
  21      def __init__(self, inference_state):
  22          self.inference_state = inference_state
  23          self.predefined_names = {}
  24  
  25      @abstractmethod
  26      def get_filters(self, until_position=None, origin_scope=None):
  27          raise NotImplementedError
  28  
  29      def goto(self, name_or_str, position):
  30          from jedi.inference import finder
  31          filters = _get_global_filters_for_name(
  32              self, name_or_str if isinstance(name_or_str, Name) else None, position,
  33          )
  34          names = finder.filter_name(filters, name_or_str)
  35          debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names)
  36          return names
  37  
  38      def py__getattribute__(self, name_or_str, name_context=None, position=None,
  39                             analysis_errors=True):
  40          """
  41          :param position: Position of the last statement -> tuple of line, column
  42          """
  43          if name_context is None:
  44              name_context = self
  45          names = self.goto(name_or_str, position)
  46  
  47          string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
  48  
  49          # This paragraph is currently needed for proper branch type inference
  50          # (static analysis).
  51          found_predefined_types = None
  52          if self.predefined_names and isinstance(name_or_str, Name):
  53              node = name_or_str
  54              while node is not None and not parser_utils.is_scope(node):
  55                  node = node.parent
  56                  if node.type in ("if_stmt", "for_stmt", "comp_for", 'sync_comp_for'):
  57                      try:
  58                          name_dict = self.predefined_names[node]
  59                          types = name_dict[string_name]
  60                      except KeyError:
  61                          continue
  62                      else:
  63                          found_predefined_types = types
  64                          break
  65          if found_predefined_types is not None and names:
  66              from jedi.inference import flow_analysis
  67              check = flow_analysis.reachability_check(
  68                  context=self,
  69                  value_scope=self.tree_node,
  70                  node=name_or_str,
  71              )
  72              if check is flow_analysis.UNREACHABLE:
  73                  values = NO_VALUES
  74              else:
  75                  values = found_predefined_types
  76          else:
  77              values = ValueSet.from_sets(name.infer() for name in names)
  78  
  79          if not names and not values and analysis_errors:
  80              if isinstance(name_or_str, Name):
  81                  from jedi.inference import analysis
  82                  message = ("NameError: name '%s' is not defined." % string_name)
  83                  analysis.add(name_context, 'name-error', name_or_str, message)
  84  
  85          debug.dbg('context.names_to_types: %s -> %s', names, values)
  86          if values:
  87              return values
  88          return self._check_for_additional_knowledge(name_or_str, name_context, position)
  89  
  90      def _check_for_additional_knowledge(self, name_or_str, name_context, position):
  91          name_context = name_context or self
  92          # Add isinstance and other if/assert knowledge.
  93          if isinstance(name_or_str, Name) and not name_context.is_instance():
  94              flow_scope = name_or_str
  95              base_nodes = [name_context.tree_node]
  96  
  97              if any(b.type in ('comp_for', 'sync_comp_for') for b in base_nodes):
  98                  return NO_VALUES
  99              from jedi.inference.finder import check_flow_information
 100              while True:
 101                  flow_scope = get_parent_scope(flow_scope, include_flows=True)
 102                  n = check_flow_information(name_context, flow_scope,
 103                                             name_or_str, position)
 104                  if n is not None:
 105                      return n
 106                  if flow_scope in base_nodes:
 107                      break
 108          return NO_VALUES
 109  
 110      def get_root_context(self):
 111          parent_context = self.parent_context
 112          if parent_context is None:
 113              return self
 114          return parent_context.get_root_context()
 115  
 116      def is_module(self):
 117          return False
 118  
 119      def is_builtins_module(self):
 120          return False
 121  
 122      def is_class(self):
 123          return False
 124  
 125      def is_stub(self):
 126          return False
 127  
 128      def is_instance(self):
 129          return False
 130  
 131      def is_compiled(self):
 132          return False
 133  
 134      def is_bound_method(self):
 135          return False
 136  
 137      @abstractmethod
 138      def py__name__(self):
 139          raise NotImplementedError
 140  
 141      def get_value(self):
 142          raise NotImplementedError
 143  
 144      @property
 145      def name(self):
 146          return None
 147  
 148      def get_qualified_names(self):
 149          return ()
 150  
 151      def py__doc__(self):
 152          return ''
 153  
 154      @contextmanager
 155      def predefine_names(self, flow_scope, dct):
 156          predefined = self.predefined_names
 157          predefined[flow_scope] = dct
 158          try:
 159              yield
 160          finally:
 161              del predefined[flow_scope]
 162  
 163  
 164  class ValueContext(AbstractContext):
 165      """
 166      Should be defined, otherwise the API returns empty types.
 167      """
 168      def __init__(self, value):
 169          super().__init__(value.inference_state)
 170          self._value = value
 171  
 172      @property
 173      def tree_node(self):
 174          return self._value.tree_node
 175  
 176      @property
 177      def parent_context(self):
 178          return self._value.parent_context
 179  
 180      def is_module(self):
 181          return self._value.is_module()
 182  
 183      def is_builtins_module(self):
 184          return self._value == self.inference_state.builtins_module
 185  
 186      def is_class(self):
 187          return self._value.is_class()
 188  
 189      def is_stub(self):
 190          return self._value.is_stub()
 191  
 192      def is_instance(self):
 193          return self._value.is_instance()
 194  
 195      def is_compiled(self):
 196          return self._value.is_compiled()
 197  
 198      def is_bound_method(self):
 199          return self._value.is_bound_method()
 200  
 201      def py__name__(self):
 202          return self._value.py__name__()
 203  
 204      @property
 205      def name(self):
 206          return self._value.name
 207  
 208      def get_qualified_names(self):
 209          return self._value.get_qualified_names()
 210  
 211      def py__doc__(self):
 212          return self._value.py__doc__()
 213  
 214      def get_value(self):
 215          return self._value
 216  
 217      def __repr__(self):
 218          return '%s(%s)' % (self.__class__.__name__, self._value)
 219  
 220  
 221  class TreeContextMixin:
 222      def infer_node(self, node):
 223          from jedi.inference.syntax_tree import infer_node
 224          return infer_node(self, node)
 225  
 226      def create_value(self, node):
 227          from jedi.inference import value
 228  
 229          if node == self.tree_node:
 230              assert self.is_module()
 231              return self.get_value()
 232  
 233          parent_context = self.create_context(node)
 234  
 235          if node.type in ('funcdef', 'lambdef'):
 236              func = value.FunctionValue.from_context(parent_context, node)
 237              if parent_context.is_class():
 238                  class_value = parent_context.parent_context.create_value(parent_context.tree_node)
 239                  instance = value.AnonymousInstance(
 240                      self.inference_state, parent_context.parent_context, class_value)
 241                  func = value.BoundMethod(
 242                      instance=instance,
 243                      class_context=class_value.as_context(),
 244                      function=func
 245                  )
 246              return func
 247          elif node.type == 'classdef':
 248              return value.ClassValue(self.inference_state, parent_context, node)
 249          else:
 250              raise NotImplementedError("Probably shouldn't happen: %s" % node)
 251  
 252      def create_context(self, node):
 253          def from_scope_node(scope_node, is_nested=True):
 254              if scope_node == self.tree_node:
 255                  return self
 256  
 257              if scope_node.type in ('funcdef', 'lambdef', 'classdef'):
 258                  return self.create_value(scope_node).as_context()
 259              elif scope_node.type in ('comp_for', 'sync_comp_for'):
 260                  parent_context = from_scope_node(parent_scope(scope_node.parent))
 261                  if node.start_pos >= scope_node.children[-1].start_pos:
 262                      return parent_context
 263                  return CompForContext(parent_context, scope_node)
 264              raise Exception("There's a scope that was not managed: %s" % scope_node)
 265  
 266          def parent_scope(node):
 267              while True:
 268                  node = node.parent
 269  
 270                  if parser_utils.is_scope(node):
 271                      return node
 272                  elif node.type in ('argument', 'testlist_comp'):
 273                      if node.children[1].type in ('comp_for', 'sync_comp_for'):
 274                          return node.children[1]
 275                  elif node.type == 'dictorsetmaker':
 276                      for n in node.children[1:4]:
 277                          # In dictionaries it can be pretty much anything.
 278                          if n.type in ('comp_for', 'sync_comp_for'):
 279                              return n
 280  
 281          scope_node = parent_scope(node)
 282          if scope_node.type in ('funcdef', 'classdef'):
 283              colon = scope_node.children[scope_node.children.index(':')]
 284              if node.start_pos < colon.start_pos:
 285                  parent = node.parent
 286                  if not (parent.type == 'param' and parent.name == node):
 287                      scope_node = parent_scope(scope_node)
 288          return from_scope_node(scope_node, is_nested=True)
 289  
 290      def create_name(self, tree_name):
 291          definition = tree_name.get_definition()
 292          if definition and definition.type == 'param' and definition.name == tree_name:
 293              funcdef = search_ancestor(definition, 'funcdef', 'lambdef')
 294              func = self.create_value(funcdef)
 295              return AnonymousParamName(func, tree_name)
 296          else:
 297              context = self.create_context(tree_name)
 298              return TreeNameDefinition(context, tree_name)
 299  
 300  
 301  class FunctionContext(TreeContextMixin, ValueContext):
 302      def get_filters(self, until_position=None, origin_scope=None):
 303          yield ParserTreeFilter(
 304              self.inference_state,
 305              parent_context=self,
 306              until_position=until_position,
 307              origin_scope=origin_scope
 308          )
 309  
 310  
 311  class ModuleContext(TreeContextMixin, ValueContext):
 312      def py__file__(self) -> Optional[Path]:
 313          return self._value.py__file__()  # type: ignore[no-any-return]
 314  
 315      def get_filters(self, until_position=None, origin_scope=None):
 316          filters = self._value.get_filters(origin_scope)
 317          # Skip the first filter and replace it.
 318          next(filters, None)
 319          yield MergedFilter(
 320              ParserTreeFilter(
 321                  parent_context=self,
 322                  until_position=until_position,
 323                  origin_scope=origin_scope
 324              ),
 325              self.get_global_filter(),
 326          )
 327          yield from filters
 328  
 329      def get_global_filter(self):
 330          return GlobalNameFilter(self)
 331  
 332      @property
 333      def string_names(self):
 334          return self._value.string_names
 335  
 336      @property
 337      def code_lines(self):
 338          return self._value.code_lines
 339  
 340      def get_value(self):
 341          """
 342          This is the only function that converts a context back to a value.
 343          This is necessary for stub -> python conversion and vice versa. However
 344          this method shouldn't be moved to AbstractContext.
 345          """
 346          return self._value
 347  
 348  
 349  class NamespaceContext(TreeContextMixin, ValueContext):
 350      def get_filters(self, until_position=None, origin_scope=None):
 351          return self._value.get_filters()
 352  
 353      def get_value(self):
 354          return self._value
 355  
 356      @property
 357      def string_names(self):
 358          return self._value.string_names
 359  
 360      def py__file__(self) -> Optional[Path]:
 361          return self._value.py__file__()  # type: ignore[no-any-return]
 362  
 363  
 364  class ClassContext(TreeContextMixin, ValueContext):
 365      def get_filters(self, until_position=None, origin_scope=None):
 366          yield self.get_global_filter(until_position, origin_scope)
 367  
 368      def get_global_filter(self, until_position=None, origin_scope=None):
 369          return ParserTreeFilter(
 370              parent_context=self,
 371              until_position=until_position,
 372              origin_scope=origin_scope
 373          )
 374  
 375  
 376  class CompForContext(TreeContextMixin, AbstractContext):
 377      def __init__(self, parent_context, comp_for):
 378          super().__init__(parent_context.inference_state)
 379          self.tree_node = comp_for
 380          self.parent_context = parent_context
 381  
 382      def get_filters(self, until_position=None, origin_scope=None):
 383          yield ParserTreeFilter(self)
 384  
 385      def get_value(self):
 386          return None
 387  
 388      def py__name__(self):
 389          return '<comprehension context>'
 390  
 391      def __repr__(self):
 392          return '%s(%s)' % (self.__class__.__name__, self.tree_node)
 393  
 394  
 395  class CompiledContext(ValueContext):
 396      def get_filters(self, until_position=None, origin_scope=None):
 397          return self._value.get_filters()
 398  
 399  
 400  class CompiledModuleContext(CompiledContext):
 401      code_lines = None
 402  
 403      def get_value(self):
 404          return self._value
 405  
 406      @property
 407      def string_names(self):
 408          return self._value.string_names
 409  
 410      def py__file__(self) -> Optional[Path]:
 411          return self._value.py__file__()  # type: ignore[no-any-return]
 412  
 413  
 414  def _get_global_filters_for_name(context, name_or_none, position):
 415      # For functions and classes the defaults don't belong to the
 416      # function and get inferred in the value before the function. So
 417      # make sure to exclude the function/class name.
 418      if name_or_none is not None:
 419          ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef')
 420          lambdef = None
 421          if ancestor == 'lambdef':
 422              # For lambdas it's even more complicated since parts will
 423              # be inferred later.
 424              lambdef = ancestor
 425              ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef')
 426          if ancestor is not None:
 427              colon = ancestor.children[-2]
 428              if position is not None and position < colon.start_pos:
 429                  if lambdef is None or position < lambdef.children[-2].start_pos:
 430                      position = ancestor.start_pos
 431  
 432      return get_global_filters(context, position, name_or_none)
 433  
 434  
 435  def get_global_filters(context, until_position, origin_scope):
 436      """
 437      Returns all filters in order of priority for name resolution.
 438  
 439      For global name lookups. The filters will handle name resolution
 440      themselves, but here we gather possible filters downwards.
 441  
 442      >>> from jedi import Script
 443      >>> script = Script('''
 444      ... x = ['a', 'b', 'c']
 445      ... def func():
 446      ...     y = None
 447      ... ''')
 448      >>> module_node = script._module_node
 449      >>> scope = next(module_node.iter_funcdefs())
 450      >>> scope
 451      <Function: func@3-5>
 452      >>> context = script._get_module_context().create_context(scope)
 453      >>> filters = list(get_global_filters(context, (4, 0), None))
 454  
 455      First we get the names from the function scope.
 456  
 457      >>> print(filters[0])  # doctest: +ELLIPSIS
 458      MergedFilter(<ParserTreeFilter: ...>, <GlobalNameFilter: ...>)
 459      >>> sorted(str(n) for n in filters[0].values())  # doctest: +NORMALIZE_WHITESPACE
 460      ['<TreeNameDefinition: string_name=func start_pos=(3, 4)>',
 461       '<TreeNameDefinition: string_name=x start_pos=(2, 0)>']
 462      >>> filters[0]._filters[0]._until_position
 463      (4, 0)
 464      >>> filters[0]._filters[1]._until_position
 465  
 466      Then it yields the names from one level "lower". In this example, this is
 467      the module scope (including globals).
 468      As a side note, you can see, that the position in the filter is None on the
 469      globals filter, because there the whole module is searched.
 470  
 471      >>> list(filters[1].values())  # package modules -> Also empty.
 472      []
 473      >>> sorted(name.string_name for name in filters[2].values())  # Module attributes
 474      ['__doc__', '__name__', '__package__']
 475  
 476      Finally, it yields the builtin filter, if `include_builtin` is
 477      true (default).
 478  
 479      >>> list(filters[3].values())  # doctest: +ELLIPSIS
 480      [...]
 481      """
 482      base_context = context
 483      from jedi.inference.value.function import BaseFunctionExecutionContext
 484      while context is not None:
 485          # Names in methods cannot be resolved within the class.
 486          yield from context.get_filters(
 487              until_position=until_position,
 488              origin_scope=origin_scope
 489          )
 490          if isinstance(context, (BaseFunctionExecutionContext, ModuleContext)):
 491              # The position should be reset if the current scope is a function.
 492              until_position = None
 493  
 494          context = context.parent_context
 495  
 496      b = next(base_context.inference_state.builtins_module.get_filters(), None)
 497      assert b is not None
 498      # Add builtins to the global scope.
 499      yield b
 500