Cleaning up evaluate.helpers.

jedi/api/classes.py

@@ -10,7 +10,6 @@ from jedi._compatibility import next, unicode, use_metaclass
 from jedi import settings
 from jedi import common
 from jedi.parser import tree as pr
-from jedi.evaluate.helpers import statement_elements_in_statement
 from jedi.evaluate.cache import memoize_default, CachedMetaClass
 from jedi.evaluate import representation as er
 from jedi.evaluate import iterable

jedi/evaluate/helpers.py

@@ -1,9 +1,7 @@
 import copy
 from itertools import chain
 
-from jedi._compatibility import unicode
 from jedi.parser import tree as pr
-from jedi import debug
 
 
 def deep_ast_copy(obj, new_elements_default=None, check_first=False):
@@ -106,7 +104,7 @@ def deep_ast_copy(obj, new_elements_default=None, check_first=False):
     for unfinished in unfinished_parents:
         try:
             unfinished.parent = new_elements[unfinished.parent]
-        except KeyError: # TODO this keyerror is useless.
+        except KeyError:  # TODO this keyerror is useless.
             pass
 
     return result
@@ -146,143 +144,6 @@ def call_of_name(name, cut_own_trailer=False):
     return par
 
 
-def _call_signature_array_for_pos(stmt, pos):
-    """
-    Searches for the array and position of a tuple.
-    Returns a tuple of (array, index-in-the-array, call).
-    """
-    def search_array(arr, pos, origin_call=None):
-        accepted_types = pr.Array.TUPLE, pr.Array.NOARRAY
-        if arr.type == 'dict':
-            for stmt in arr.values + arr.keys:
-                tup = _call_signature_array_for_pos(stmt, pos)
-                if tup[0] is not None:
-                    return tup
-        else:
-            for i, stmt in enumerate(arr):
-                tup = _call_signature_array_for_pos(stmt, pos)
-                if tup[0] is not None:
-                    return tup
-
-                # Since we need the index, we duplicate efforts (with empty
-                # arrays).
-                if arr.start_pos < pos <= stmt.end_pos:
-                    if arr.type in accepted_types and origin_call:
-                        return arr, i, origin_call
-
-        if len(arr) == 0 and arr.start_pos < pos < arr.end_pos:
-            if arr.type in accepted_types and origin_call:
-                return arr, 0, origin_call
-        return None, 0, None
-
-    def search_call(call, pos, origin_call=None):
-        tup = None, 0, None
-        while call.next is not None and tup[0] is None:
-            method = search_array if isinstance(call.next, pr.Array) else search_call
-            # TODO This is wrong, don't call search_call again, because it will
-            # automatically be called by call.next.
-            tup = method(call.next, pos, origin_call or call)
-            call = call.next
-        return tup
-
-    if stmt.start_pos >= pos >= stmt.end_pos:
-        return None, 0, None
-
-    tup = None, 0, None
-    # TODO this is still old
-    for command in [] and stmt.expression_list():
-        if isinstance(command, pr.Array):
-            tup = search_array(command, pos)
-        elif isinstance(command, pr.StatementElement):
-            tup = search_call(command, pos, command)
-        if tup[0] is not None:
-            break
-    return tup
-
-
-def scan_node_for_call_signature(node, pos):
-    """to something with call_signatures"""
-    if node.type == 'power' and node.start_pos < pos < node.end_pos:
-        for i, trailer in enumerate(node.children[1:], 1):
-            if trailer.type == 'trailer' and trailer.children[0] == '(' \
-                    and trailer.children[0].start_pos < pos \
-                    and pos <= trailer.children[-1].start_pos:
-                # Delete all the nodes including the current one
-                node.children[i:] = []
-                return node, trailer
-    for child in node.children:
-        node, trailer = scan_node_for_call_signature(child, pos)
-        if node is not None:
-            return node, trailer
-    return None, None
-
-
-def search_call_signatures(user_stmt, position):
-    """
-    Returns the function Call that matches the position before.
-    """
-    debug.speed('func_call start')
-    call, arr, index = None, None, 0
-    if user_stmt is not None and isinstance(user_stmt, pr.ExprStmt):
-        # some parts will of the statement will be removed
-        user_stmt = deep_ast_copy(user_stmt)
-
-        return scan_node_for_call_signature(user_stmt, position) + (0,)
-        #arr, index, call = _call_signature_array_for_pos(user_stmt, position)
-
-        # Now remove the part after the call. Including the array from the
-        # statement.
-        stmt_el = call
-        # TODO REMOVE this? or change?
-        while False and isinstance(stmt_el, pr.StatementElement):
-            if stmt_el.next == arr:
-                stmt_el.next = None
-                break
-            stmt_el = stmt_el.next
-
-    debug.speed('func_call parsed')
-    return call, arr, index
-
-
-def scan_statement_for_calls(stmt, search_name, assignment_details=False):
-    """ Returns the function Calls that match search_name in an Array. """
-    def scan_array(arr, search_name):
-        result = []
-        if arr.type == pr.Array.DICT:
-            for key_stmt, value_stmt in arr.items():
-                result += scan_statement_for_calls(key_stmt, search_name)
-                result += scan_statement_for_calls(value_stmt, search_name)
-        else:
-            for stmt in arr:
-                result += scan_statement_for_calls(stmt, search_name)
-        return result
-
-    check = list(stmt.expression_list())
-    if assignment_details:
-        for expression_list, op in stmt.assignment_details:
-            check += expression_list
-
-    result = []
-    for c in check:
-        if isinstance(c, pr.Array):
-            result += scan_array(c, search_name)
-        elif isinstance(c, pr.Call):
-            s_new = c
-            while s_new is not None:
-                if isinstance(s_new, pr.Array):
-                    result += scan_array(s_new, search_name)
-                else:
-                    if search_name == unicode(s_new.name):
-                        result.append(c)
-
-                s_new = s_new.next
-        elif isinstance(c, pr.ListComprehension):
-            for s in c.stmt, c.middle, c.input:
-                result += scan_statement_for_calls(s, search_name)
-
-    return result
-
-
 def get_module_names(module, all_scopes):
     """
     Returns a dictionary with name parts as keys and their call paths as
@@ -295,52 +156,12 @@ def get_module_names(module, all_scopes):
     return chain.from_iterable(dct.values())
 
 
-def statement_elements_in_statement(stmt):
-    """
-    Returns a list of statements. Statements can contain statements again in
-    Arrays.
-    """
-    def search_stmt_el(stmt_el, stmt_els):
-        stmt_els.append(stmt_el)
-        while stmt_el is not None:
-            if isinstance(stmt_el, pr.Array):
-                for stmt in stmt_el.values + stmt_el.keys:
-                    stmt_els.extend(statement_elements_in_statement(stmt))
-            stmt_el = stmt_el.next
-
-    stmt_els = []
-    for as_name in stmt.as_names:
-        # TODO This creates a custom pr.Call, we shouldn't do that.
-        stmt_els.append(pr.Call(as_name._sub_module, as_name,
-                                as_name.start_pos, as_name.end_pos))
-
-    ass_items = chain.from_iterable(items for items, op in stmt.assignment_details)
-    for item in stmt.expression_list() + list(ass_items):
-        if isinstance(item, pr.StatementElement):
-            search_stmt_el(item, stmt_els)
-        elif isinstance(item, pr.ListComprehension):
-            for stmt in (item.stmt, item.middle, item.input):
-                stmt_els.extend(statement_elements_in_statement(stmt))
-        elif isinstance(item, pr.Lambda):
-            for stmt in item.params + item.returns:
-                stmt_els.extend(statement_elements_in_statement(stmt))
-
-    return stmt_els
-
-
 class FakeSubModule():
     line_offset = 0
     parent = None
     path = None
 
 
-class FakeArray(pr.Array):
-    def __init__(self, values, parent=None, arr_type=pr.Array.LIST):
-        p = (0, 0)
-        super(FakeArray, self).__init__(FakeSubModule, p, arr_type, parent)
-        self.values = values
-
-
 class FakeStatement(pr.ExprStmt):
     def __init__(self, values, start_pos=(0, 0), parent=None):
         self._start_pos = start_pos
@@ -400,14 +221,3 @@ class LazyName(FakeName):
     @parent.setter
     def parent(self, value):
         pass  # Do nothing, super classes can try to set the parent.
-
-
-def stmts_to_stmt(statements):
-    """
-    Sometimes we want to have something like a result_set and unite some
-    statements in one.
-    """
-    if len(statements) == 1:
-        return statements[0]
-    array = FakeArray(statements, arr_type=pr.Array.NOARRAY)
-    return FakeStatement([array])