follow_statement -> eval_statement

jedi/evaluate/__init__.py

@@ -11,23 +11,23 @@ Evaluation of Python code in |jedi| is based on three assumptions:
 * The programmer is not a total dick, e.g. like `this
   <https://github.com/davidhalter/jedi/issues/24>`_ :-)
 
-That said, there's mainly one entry point in this script: ``follow_statement``.
+That said, there's mainly one entry point in this script: ``eval_statement``.
 This is where autocompletion starts. Everything you want to complete is either
 a ``Statement`` or some special name like ``class``, which is easy to complete.
 
-Therefore you need to understand what follows after ``follow_statement``. Let's
+Therefore you need to understand what follows after ``eval_statement``. Let's
 make an example::
 
     import datetime
     datetime.date.toda# <-- cursor here
 
 First of all, this module doesn't care about completion. It really just cares
-about ``datetime.date``. At the end of the procedure ``follow_statement`` will
+about ``datetime.date``. At the end of the procedure ``eval_statement`` will
 return the ``datetime`` class.
 
 To *visualize* this (simplified):
 
-- ``follow_statement`` - ``<Statement: datetime.date>``
+- ``eval_statement`` - ``<Statement: datetime.date>``
 
     - Unpacking of the statement into ``[[<Call: datetime.date>]]``
 - ``follow_call_list``, calls ``follow_call`` with ``<Call: datetime.date>``
@@ -50,7 +50,7 @@ import would contain another Statement like this::
     from foo import bar
     Date = bar.baz
 
-Well... You get it. Just another ``follow_statement`` recursion. It's really
+Well... You get it. Just another ``eval_statement`` recursion. It's really
 easy. Just that Python is not that easy sometimes. To understand tuple
 assignments and different class scopes, a lot more code had to be written.  Yet
 we're still not talking about Descriptors and Nested List Comprehensions, just
@@ -280,7 +280,7 @@ class Evaluator(object):
                         #if r.docstr:
                             #res_new.append(r)
 
-                        scopes = self.follow_statement(r, seek_name=name_str)
+                        scopes = self.eval_statement(r, seek_name=name_str)
                         add += remove_statements(scopes)
 
                     if check_instance is not None:
@@ -310,7 +310,7 @@ class Evaluator(object):
                 # one, remember `in`). And follow it.
                 if not loop.inputs:
                     return []
-                result = get_iterator_types(self.follow_statement(loop.inputs[0]))
+                result = get_iterator_types(self.eval_statement(loop.inputs[0]))
                 if len(loop.set_vars) > 1:
                     commands = loop.set_stmt.get_commands()
                     # loops with loop.set_vars > 0 only have one command
@@ -478,7 +478,7 @@ class Evaluator(object):
 
     @memoize_default(default=(), evaluator_is_first_arg=True)
     @recursion.recursion_decorator
-    def follow_statement(self, stmt, seek_name=None):
+    def eval_statement(self, stmt, seek_name=None):
         """
         The starting point of the completion. A statement always owns a call list,
         which are the calls, that a statement does.
@@ -488,9 +488,8 @@ class Evaluator(object):
         :param stmt: A `pr.Statement`.
         :param seek_name: A string.
         """
-        debug.dbg('follow_stmt %s (%s)' % (stmt, seek_name))
+        debug.dbg('eval_statement %s (%s)' % (stmt, seek_name))
         commands = stmt.get_commands()
-        debug.dbg('calls: %s' % commands)
 
         result = self.follow_call_list(commands)
 
@@ -526,11 +525,12 @@ class Evaluator(object):
                 loop = evaluate_list_comprehension(nested_lc, loop)
             return loop
 
+        debug.dbg('follow_call_list: %s' % call_list)
         result = []
         calls_iterator = iter(call_list)
         for call in calls_iterator:
             if pr.Array.is_type(call, pr.Array.NOARRAY):
-                r = list(itertools.chain.from_iterable(self.follow_statement(s)
+                r = list(itertools.chain.from_iterable(self.eval_statement(s)
                                                        for s in call))
                 call_path = call.generate_call_path()
                 next(call_path, None)  # the first one has been used already
@@ -541,7 +541,7 @@ class Evaluator(object):
                 # Caveat: parents are being changed, but this doesn't matter,
                 # because nothing else uses it.
                 call.stmt.parent = loop
-                result += self.follow_statement(call.stmt)
+                result += self.eval_statement(call.stmt)
             else:
                 if isinstance(call, pr.Lambda):
                     result.append(er.Function(self, call))
@@ -582,7 +582,9 @@ class Evaluator(object):
         return self.follow_call_path(path, s.parent, s.start_pos)
 
     def follow_call_path(self, path, scope, position):
-        """Follows a path generated by `pr.StatementElement.generate_call_path()`"""
+        """
+        Follows a path generated by `pr.StatementElement.generate_call_path()`.
+        """
         current = next(path)
 
         if isinstance(current, pr.Array):
@@ -635,7 +637,7 @@ class Evaluator(object):
             current = next(path)
         except StopIteration:
             return None
-        debug.dbg('follow %s in scope %s' % (current, scope))
+        debug.dbg('follow_path: %s in scope %s' % (current, scope))
 
         result = []
         if isinstance(current, pr.Array):