def call_signatures(self): """ Return the function object of the call you're currently in. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return ``None``. :rtype: list of :class:`classes.CallSignature` """ user_stmt = self._parser.user_stmt_with_whitespace() call, index = search_call_signatures(user_stmt, self._pos) if call is None: return [] with common.scale_speed_settings(settings.scale_call_signatures): _callable = lambda: self._evaluator.eval_call(call) origins = cache.cache_call_signatures(_callable, self.source, self._pos, user_stmt) origins = self._evaluator.eval_call(call) debug.speed('func_call followed') return [classes.CallSignature(self._evaluator, o, call, index) for o in origins if o.is_callable()]
def func_call_and_param_index(user_stmt, position): debug.speed('func_call start') call, index = None, 0 if call is None: if user_stmt is not None and isinstance(user_stmt, pr.Statement): call, index, _ = helpers.search_call_signatures(user_stmt, position) debug.speed('func_call parsed') return call, index
def func_call_and_param_index(user_stmt, position): debug.speed('func_call start') call, index = None, 0 if call is None: if user_stmt is not None and isinstance(user_stmt, pr.Statement): call, index, _ = helpers.search_call_signatures( user_stmt, position) debug.speed('func_call parsed') return call, index
def call_signatures(self): """ Return the function object of the call you're currently in. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return ``None``. :rtype: list of :class:`classes.CallSignature` """ user_stmt = self._parser.user_stmt_with_whitespace() call, index = search_call_signatures(user_stmt, self._pos) if call is None: return [] stmt_el = call while isinstance(stmt_el.parent, pr.StatementElement): # Go to parent literal/variable until not possible anymore. This # makes it possible to return the whole expression. stmt_el = stmt_el.parent # We can reset the execution since it's a new object # (fast_parent_copy). execution_arr, call.execution = call.execution, None with common.scale_speed_settings(settings.scale_call_signatures): _callable = lambda: self._evaluator.eval_call(stmt_el) origins = cache.cache_call_signatures(_callable, self.source, self._pos, user_stmt) debug.speed('func_call followed') key_name = None try: detail = execution_arr[index].assignment_details[0] except IndexError: pass else: try: key_name = unicode(detail[0][0].name) except (IndexError, AttributeError): pass return [ classes.CallSignature(self._evaluator, o, call, index, key_name) for o in origins if o.is_callable() ]
def goto_definitions(self): """ Return the definitions of a the path under the cursor. goto function! This follows complicated paths and returns the end, not the first definition. The big difference between :meth:`goto_assignments` and :meth:`goto_definitions` is that :meth:`goto_assignments` doesn't follow imports and statements. Multiple objects may be returned, because Python itself is a dynamic language, which means depending on an option you can have two different versions of a function. :rtype: list of :class:`classes.Definition` """ def resolve_import_paths(scopes): for s in scopes.copy(): if isinstance(s, imports.ImportWrapper): scopes.remove(s) scopes.update(resolve_import_paths(set(s.follow()))) return scopes user_stmt = self._parser.user_stmt_with_whitespace() goto_path = self._user_context.get_path_under_cursor() context = self._user_context.get_context() definitions = set() if next(context) in ('class', 'def'): definitions = set([self._parser.user_scope()]) else: # Fetch definition of callee, if there's no path otherwise. if not goto_path: (call, _) = search_call_signatures(user_stmt, self._pos) if call is not None: while call.next is not None: call = call.next # reset cursor position: (row, col) = call.name.end_pos pos = (row, max(col - 1, 0)) self._user_context = UserContext(self.source, pos) # then try to find the path again goto_path = self._user_context.get_path_under_cursor() if not definitions: if goto_path: definitions = set(self._prepare_goto(goto_path)) definitions = resolve_import_paths(definitions) d = set([ classes.Definition(self._evaluator, s) for s in definitions if s is not imports.ImportWrapper.GlobalNamespace ]) return helpers.sorted_definitions(d)
def call_signatures(self): """ Return the function object of the call you're currently in. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return ``None``. :rtype: list of :class:`classes.CallSignature` """ user_stmt = self._parser.user_stmt_with_whitespace() call, index = search_call_signatures(user_stmt, self._pos) if call is None: return [] stmt_el = call while isinstance(stmt_el.parent, pr.StatementElement): # Go to parent literal/variable until not possible anymore. This # makes it possible to return the whole expression. stmt_el = stmt_el.parent # We can reset the execution since it's a new object # (fast_parent_copy). execution_arr, call.execution = call.execution, None with common.scale_speed_settings(settings.scale_call_signatures): _callable = lambda: self._evaluator.eval_call(stmt_el) origins = cache.cache_call_signatures(_callable, self.source, self._pos, user_stmt) origins = self._evaluator.eval_call(stmt_el) debug.speed('func_call followed') key_name = None try: detail = execution_arr[index].assignment_details[0] except IndexError: pass else: try: key_name = unicode(detail[0][0].name) except (IndexError, AttributeError): pass return [classes.CallSignature(self._evaluator, o, call, index, key_name) for o in origins if o.is_callable()]
def goto_definitions(self): """ Return the definitions of a the path under the cursor. goto function! This follows complicated paths and returns the end, not the first definition. The big difference between :meth:`goto_assignments` and :meth:`goto_definitions` is that :meth:`goto_assignments` doesn't follow imports and statements. Multiple objects may be returned, because Python itself is a dynamic language, which means depending on an option you can have two different versions of a function. :rtype: list of :class:`classes.Definition` """ def resolve_import_paths(scopes): for s in scopes.copy(): if isinstance(s, imports.ImportWrapper): scopes.remove(s) scopes.update(resolve_import_paths(set(s.follow()))) return scopes user_stmt = self._parser.user_stmt_with_whitespace() goto_path = self._user_context.get_path_under_cursor() context = self._user_context.get_context() definitions = set() if next(context) in ('class', 'def'): definitions = set([self._parser.user_scope()]) else: # Fetch definition of callee, if there's no path otherwise. if not goto_path: (call, _) = search_call_signatures(user_stmt, self._pos) if call is not None: while call.next is not None: call = call.next # reset cursor position: (row, col) = call.name.end_pos pos = (row, max(col - 1, 0)) self._user_context = UserContext(self.source, pos) # then try to find the path again goto_path = self._user_context.get_path_under_cursor() if not definitions: if goto_path: definitions = set(self._prepare_goto(goto_path)) definitions = resolve_import_paths(definitions) d = set([classes.Definition(self._evaluator, s) for s in definitions if s is not imports.ImportWrapper.GlobalNamespace]) return helpers.sorted_definitions(d)
def call_signatures(self): """ Return the function object of the call you're currently in. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return ``None``. :rtype: list of :class:`classes.CallSignature` """ user_stmt = self._parser.user_stmt_with_whitespace() call, execution_arr, index = search_call_signatures(user_stmt, self._pos) if call is None: return [] with common.scale_speed_settings(settings.scale_call_signatures): origins = cache.cache_call_signatures(self._evaluator, call, self.source, self._pos, user_stmt) debug.speed('func_call followed') key_name = None try: detail = execution_arr[index].assignment_details[0] except IndexError: pass else: try: key_name = unicode(detail[0][0].name) except (IndexError, AttributeError): pass return [classes.CallSignature(self._evaluator, o.name, call, index, key_name) for o in origins if hasattr(o, 'py__call__')]