From cbe93298ce15d5761b58e63ae300f94382075836 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 15:14:06 +0100
Subject: [PATCH 01/42] move evaluate and evaluate_representation to evaluate
 folder

---
 jedi/api.py                                                   | 4 ++--
 jedi/api_classes.py                                           | 4 ++--
 jedi/docstrings.py                                            | 4 ++--
 jedi/{evaluate.py => evaluate/__init__.py}                    | 2 +-
 .../representation.py}                                        | 1 -
 jedi/imports.py                                               | 1 -
 jedi/recursion.py                                             | 2 +-
 7 files changed, 8 insertions(+), 10 deletions(-)
 rename jedi/{evaluate.py => evaluate/__init__.py} (99%)
 rename jedi/{evaluate_representation.py => evaluate/representation.py} (99%)

diff --git a/jedi/api.py b/jedi/api.py
index e14b0ac7..7d369f86 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -25,10 +25,10 @@ from jedi import cache
 from jedi import modules
 from jedi import interpret
 from jedi._compatibility import next, unicode, builtins
+from jedi import evaluate
+from jedi.evaluate import representation as er
 import keywords
-import evaluate
 import api_classes
-import evaluate_representation as er
 import dynamic
 import imports
 import builtin
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index ccbb576d..f2fb1a5c 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -13,12 +13,12 @@ from jedi import settings
 from jedi import common
 from jedi.parser import representation as pr
 from jedi import cache
+from jedi import evaluate
+from jedi import representation as er
 import keywords
 import recursion
 import dynamic
-import evaluate
 import imports
-import evaluate_representation as er
 
 
 def _clear_caches():
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index bbc3777b..4ae7c842 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -18,8 +18,8 @@ import re
 
 from jedi import cache
 from jedi.parser import Parser
-import evaluate
-import evaluate_representation as er
+from jedi import evaluate
+from jedi.evaluate import representation as er
 
 DOCSTRING_PARAM_PATTERNS = [
     r'\s*:type\s+%s:\s*([^\n]+)',  # Sphinx
diff --git a/jedi/evaluate.py b/jedi/evaluate/__init__.py
similarity index 99%
rename from jedi/evaluate.py
rename to jedi/evaluate/__init__.py
index a510f4c3..ae3d5036 100644
--- a/jedi/evaluate.py
+++ b/jedi/evaluate/__init__.py
@@ -78,7 +78,7 @@ from jedi import common
 from jedi import cache
 from jedi.parser import representation as pr
 from jedi import debug
-import evaluate_representation as er
+from jedi.evaluate import representation as er
 import recursion
 import docstrings
 import builtin
diff --git a/jedi/evaluate_representation.py b/jedi/evaluate/representation.py
similarity index 99%
rename from jedi/evaluate_representation.py
rename to jedi/evaluate/representation.py
index 2abb8aa0..c5b63fca 100644
--- a/jedi/evaluate_representation.py
+++ b/jedi/evaluate/representation.py
@@ -23,7 +23,6 @@ from jedi import common
 import recursion
 import docstrings
 import imports
-import evaluate
 import builtin
 import dynamic
 
diff --git a/jedi/imports.py b/jedi/imports.py
index a34753fc..a28b94e0 100644
--- a/jedi/imports.py
+++ b/jedi/imports.py
@@ -25,7 +25,6 @@ from jedi import debug
 from jedi.parser import representation as pr
 from jedi import cache
 import builtin
-import evaluate
 
 # for debugging purposes only
 imports_processed = 0
diff --git a/jedi/recursion.py b/jedi/recursion.py
index 82df1826..da083372 100644
--- a/jedi/recursion.py
+++ b/jedi/recursion.py
@@ -10,7 +10,7 @@ calls.
 from jedi.parser import representation as pr
 from jedi import debug
 from jedi import settings
-import evaluate_representation as er
+from jedi.evaluate import representation as er
 import builtin
 
 

From 5f4bcd330c071833f173f0b2237f72325007b749 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 15:21:09 +0100
Subject: [PATCH 02/42] evaluator class introduction

---
 jedi/evaluate/__init__.py | 944 +++++++++++++++++++-------------------
 1 file changed, 469 insertions(+), 475 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index ae3d5036..0d7cf306 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -202,274 +202,502 @@ def get_names_of_scope(scope, position=None, star_search=True,
             yield builtin_scope, builtin_scope.get_defined_names()
 
 
-def find_name(scope, name_str, position=None, search_global=False,
-              is_goto=False, resolve_decorator=True):
-    """
-    This is the search function. The most important part to debug.
-    `remove_statements` and `filter_statements` really are the core part of
-    this completion.
-
-    :param position: Position of the last statement -> tuple of line, column
-    :return: List of Names. Their parents are the scopes, they are defined in.
-    :rtype: list
-    """
-    def remove_statements(result):
+class Evaluator(object):
+    def find_name(self, scope, name_str, position=None, search_global=False,
+                  is_goto=False, resolve_decorator=True):
         """
-        This is the part where statements are being stripped.
+        This is the search function. The most important part to debug.
+        `remove_statements` and `filter_statements` really are the core part of
+        this completion.
 
-        Due to lazy evaluation, statements like a = func; b = a; b() have to be
-        evaluated.
+        :param position: Position of the last statement -> tuple of line, column
+        :return: List of Names. Their parents are the scopes, they are defined in.
+        :rtype: list
         """
-        res_new = []
-        for r in result:
-            add = []
-            if r.isinstance(pr.Statement):
-                check_instance = None
-                if isinstance(r, er.InstanceElement) and r.is_class_var:
-                    check_instance = r.instance
-                    r = r.var
+        def remove_statements(result):
+            """
+            This is the part where statements are being stripped.
 
-                # Global variables handling.
-                if r.is_global():
-                    for token_name in r.token_list[1:]:
-                        if isinstance(token_name, pr.Name):
-                            add = find_name(r.parent, str(token_name))
-                else:
-                    # generated objects are used within executions, but these
-                    # objects are in functions, and we have to dynamically
-                    # execute first.
-                    if isinstance(r, pr.Param):
-                        func = r.parent
-                        # Instances are typically faked, if the instance is not
-                        # called from outside. Here we check it for __init__
-                        # functions and return.
-                        if isinstance(func, er.InstanceElement) \
-                                and func.instance.is_generated \
-                                and hasattr(func, 'name') \
-                                and str(func.name) == '__init__' \
-                                and r.position_nr > 0:  # 0 would be self
-                            r = func.var.params[r.position_nr]
+            Due to lazy evaluation, statements like a = func; b = a; b() have to be
+            evaluated.
+            """
+            res_new = []
+            for r in result:
+                add = []
+                if r.isinstance(pr.Statement):
+                    check_instance = None
+                    if isinstance(r, er.InstanceElement) and r.is_class_var:
+                        check_instance = r.instance
+                        r = r.var
 
-                        # add docstring knowledge
-                        doc_params = docstrings.follow_param(r)
-                        if doc_params:
-                            res_new += doc_params
-                            continue
+                    # Global variables handling.
+                    if r.is_global():
+                        for token_name in r.token_list[1:]:
+                            if isinstance(token_name, pr.Name):
+                                add = self.find_name(r.parent, str(token_name))
+                    else:
+                        # generated objects are used within executions, but these
+                        # objects are in functions, and we have to dynamically
+                        # execute first.
+                        if isinstance(r, pr.Param):
+                            func = r.parent
+                            # Instances are typically faked, if the instance is not
+                            # called from outside. Here we check it for __init__
+                            # functions and return.
+                            if isinstance(func, er.InstanceElement) \
+                                    and func.instance.is_generated \
+                                    and hasattr(func, 'name') \
+                                    and str(func.name) == '__init__' \
+                                    and r.position_nr > 0:  # 0 would be self
+                                r = func.var.params[r.position_nr]
 
-                        if not r.is_generated:
-                            res_new += dynamic.search_params(r)
-                            if not res_new:
-                                c = r.get_commands()[0]
-                                if c in ('*', '**'):
-                                    t = 'tuple' if c == '*' else 'dict'
-                                    res_new = [er.Instance(
-                                        find_name(builtin.Builtin.scope, t)[0])
-                                    ]
-                            if not r.assignment_details:
-                                # this means that there are no default params,
-                                # so just ignore it.
+                            # add docstring knowledge
+                            doc_params = docstrings.follow_param(r)
+                            if doc_params:
+                                res_new += doc_params
                                 continue
 
-                    # Remove the statement docstr stuff for now, that has to be
-                    # implemented with the evaluator class.
-                    #if r.docstr:
-                        #res_new.append(r)
+                            if not r.is_generated:
+                                res_new += dynamic.search_params(r)
+                                if not res_new:
+                                    c = r.get_commands()[0]
+                                    if c in ('*', '**'):
+                                        t = 'tuple' if c == '*' else 'dict'
+                                        res_new = [er.Instance(
+                                            self.find_name(builtin.Builtin.scope, t)[0])
+                                        ]
+                                if not r.assignment_details:
+                                    # this means that there are no default params,
+                                    # so just ignore it.
+                                    continue
 
-                    scopes = follow_statement(r, seek_name=name_str)
-                    add += remove_statements(scopes)
+                        # Remove the statement docstr stuff for now, that has to be
+                        # implemented with the evaluator class.
+                        #if r.docstr:
+                            #res_new.append(r)
 
-                if check_instance is not None:
-                    # class renames
-                    add = [er.InstanceElement(check_instance, a, True)
-                           if isinstance(a, (er.Function, pr.Function))
-                           else a for a in add]
-                res_new += add
-            else:
-                if isinstance(r, pr.Class):
-                    r = er.Class(r)
-                elif isinstance(r, pr.Function):
-                    r = er.Function(r)
-                if r.isinstance(er.Function) and resolve_decorator:
-                    r = r.get_decorated_func()
-                res_new.append(r)
-        debug.dbg('sfn remove, new: %s, old: %s' % (res_new, result))
-        return res_new
+                        scopes = self.follow_statement(r, seek_name=name_str)
+                        add += remove_statements(scopes)
 
-    def filter_name(scope_generator):
-        """
-        Filters all variables of a scope (which are defined in the
-        `scope_generator`), until the name fits.
-        """
-        def handle_for_loops(loop):
-            # Take the first statement (for has always only
-            # one, remember `in`). And follow it.
-            if not loop.inputs:
-                return []
-            result = get_iterator_types(follow_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
-                result = assign_tuples(commands[0], result, name_str)
-            return result
+                    if check_instance is not None:
+                        # class renames
+                        add = [er.InstanceElement(check_instance, a, True)
+                               if isinstance(a, (er.Function, pr.Function))
+                               else a for a in add]
+                    res_new += add
+                else:
+                    if isinstance(r, pr.Class):
+                        r = er.Class(r)
+                    elif isinstance(r, pr.Function):
+                        r = er.Function(r)
+                    if r.isinstance(er.Function) and resolve_decorator:
+                        r = r.get_decorated_func()
+                    res_new.append(r)
+            debug.dbg('sfn remove, new: %s, old: %s' % (res_new, result))
+            return res_new
 
-        def process(name):
+        def filter_name(scope_generator):
             """
-            Returns the parent of a name, which means the element which stands
-            behind a name.
+            Filters all variables of a scope (which are defined in the
+            `scope_generator`), until the name fits.
             """
-            result = []
-            no_break_scope = False
-            par = name.parent
-            exc = pr.Class, pr.Function
-            until = lambda: par.parent.parent.get_parent_until(exc)
-            is_array_assignment = False
+            def handle_for_loops(loop):
+                # Take the first statement (for has always only
+                # one, remember `in`). And follow it.
+                if not loop.inputs:
+                    return []
+                result = get_iterator_types(self.follow_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
+                    result = assign_tuples(commands[0], result, name_str)
+                return result
 
-            if par is None:
-                pass
-            elif par.isinstance(pr.Flow):
-                if par.command == 'for':
-                    result += handle_for_loops(par)
-                else:
-                    debug.warning('Flow: Why are you here? %s' % par.command)
-            elif par.isinstance(pr.Param) \
-                    and par.parent is not None \
-                    and isinstance(until(), pr.Class) \
-                    and par.position_nr == 0:
-                # This is where self gets added - this happens at another
-                # place, if the var_args are clear. But sometimes the class is
-                # not known. Therefore add a new instance for self. Otherwise
-                # take the existing.
-                if isinstance(scope, er.InstanceElement):
-                    inst = scope.instance
-                else:
-                    inst = er.Instance(er.Class(until()))
-                    inst.is_generated = True
-                result.append(inst)
-            elif par.isinstance(pr.Statement):
-                def is_execution(calls):
-                    for c in calls:
-                        if isinstance(c, (unicode, str)):
-                            continue
-                        if c.isinstance(pr.Array):
-                            if is_execution(c):
-                                return True
-                        elif c.isinstance(pr.Call):
-                            # Compare start_pos, because names may be different
-                            # because of executions.
-                            if c.name.start_pos == name.start_pos \
-                                    and c.execution:
-                                return True
-                    return False
+            def process(name):
+                """
+                Returns the parent of a name, which means the element which stands
+                behind a name.
+                """
+                result = []
+                no_break_scope = False
+                par = name.parent
+                exc = pr.Class, pr.Function
+                until = lambda: par.parent.parent.get_parent_until(exc)
+                is_array_assignment = False
 
-                is_exe = False
-                for assignee, op in par.assignment_details:
-                    is_exe |= is_execution(assignee)
-
-                if is_exe:
-                    # filter array[3] = ...
-                    # TODO check executions for dict contents
-                    is_array_assignment = True
-                else:
-                    details = par.assignment_details
-                    if details and details[0][1] != '=':
-                        no_break_scope = True
-
-                    # TODO this makes self variables non-breakable. wanted?
-                    if isinstance(name, er.InstanceElement) \
-                            and not name.is_class_var:
-                        no_break_scope = True
-
-                    result.append(par)
-            else:
-                # TODO multi-level import non-breakable
-                if isinstance(par, pr.Import) and len(par.namespace) > 1:
-                    no_break_scope = True
-                result.append(par)
-            return result, no_break_scope, is_array_assignment
-
-        flow_scope = scope
-        result = []
-        # compare func uses the tuple of line/indent = line/column
-        comparison_func = lambda name: (name.start_pos)
-
-        for nscope, name_list in scope_generator:
-            break_scopes = []
-            # here is the position stuff happening (sorting of variables)
-            for name in sorted(name_list, key=comparison_func, reverse=True):
-                p = name.parent.parent if name.parent else None
-                if isinstance(p, er.InstanceElement) \
-                        and isinstance(p.var, pr.Class):
-                    p = p.var
-                if name_str == name.get_code() and p not in break_scopes:
-                    r, no_break_scope, is_array_assignment = process(name)
-                    if is_goto:
-                        if not is_array_assignment:  # shouldn't goto arr[1] =
-                            result.append(name)
+                if par is None:
+                    pass
+                elif par.isinstance(pr.Flow):
+                    if par.command == 'for':
+                        result += handle_for_loops(par)
                     else:
-                        result += r
-                    # for comparison we need the raw class
-                    s = nscope.base if isinstance(nscope, er.Class) else nscope
-                    # this means that a definition was found and is not e.g.
-                    # in if/else.
-                    if result and not no_break_scope:
-                        if not name.parent or p == s:
-                            break
-                        break_scopes.append(p)
+                        debug.warning('Flow: Why are you here? %s' % par.command)
+                elif par.isinstance(pr.Param) \
+                        and par.parent is not None \
+                        and isinstance(until(), pr.Class) \
+                        and par.position_nr == 0:
+                    # This is where self gets added - this happens at another
+                    # place, if the var_args are clear. But sometimes the class is
+                    # not known. Therefore add a new instance for self. Otherwise
+                    # take the existing.
+                    if isinstance(scope, er.InstanceElement):
+                        inst = scope.instance
+                    else:
+                        inst = er.Instance(er.Class(until()))
+                        inst.is_generated = True
+                    result.append(inst)
+                elif par.isinstance(pr.Statement):
+                    def is_execution(calls):
+                        for c in calls:
+                            if isinstance(c, (unicode, str)):
+                                continue
+                            if c.isinstance(pr.Array):
+                                if is_execution(c):
+                                    return True
+                            elif c.isinstance(pr.Call):
+                                # Compare start_pos, because names may be different
+                                # because of executions.
+                                if c.name.start_pos == name.start_pos \
+                                        and c.execution:
+                                    return True
+                        return False
 
-            while flow_scope:
-                # TODO check if result is in scope -> no evaluation necessary
-                n = dynamic.check_flow_information(flow_scope, name_str,
-                                                   position)
-                if n:
-                    result = n
-                    break
+                    is_exe = False
+                    for assignee, op in par.assignment_details:
+                        is_exe |= is_execution(assignee)
 
+                    if is_exe:
+                        # filter array[3] = ...
+                        # TODO check executions for dict contents
+                        is_array_assignment = True
+                    else:
+                        details = par.assignment_details
+                        if details and details[0][1] != '=':
+                            no_break_scope = True
+
+                        # TODO this makes self variables non-breakable. wanted?
+                        if isinstance(name, er.InstanceElement) \
+                                and not name.is_class_var:
+                            no_break_scope = True
+
+                        result.append(par)
+                else:
+                    # TODO multi-level import non-breakable
+                    if isinstance(par, pr.Import) and len(par.namespace) > 1:
+                        no_break_scope = True
+                    result.append(par)
+                return result, no_break_scope, is_array_assignment
+
+            flow_scope = scope
+            result = []
+            # compare func uses the tuple of line/indent = line/column
+            comparison_func = lambda name: (name.start_pos)
+
+            for nscope, name_list in scope_generator:
+                break_scopes = []
+                # here is the position stuff happening (sorting of variables)
+                for name in sorted(name_list, key=comparison_func, reverse=True):
+                    p = name.parent.parent if name.parent else None
+                    if isinstance(p, er.InstanceElement) \
+                            and isinstance(p.var, pr.Class):
+                        p = p.var
+                    if name_str == name.get_code() and p not in break_scopes:
+                        r, no_break_scope, is_array_assignment = process(name)
+                        if is_goto:
+                            if not is_array_assignment:  # shouldn't goto arr[1] =
+                                result.append(name)
+                        else:
+                            result += r
+                        # for comparison we need the raw class
+                        s = nscope.base if isinstance(nscope, er.Class) else nscope
+                        # this means that a definition was found and is not e.g.
+                        # in if/else.
+                        if result and not no_break_scope:
+                            if not name.parent or p == s:
+                                break
+                            break_scopes.append(p)
+
+                while flow_scope:
+                    # TODO check if result is in scope -> no evaluation necessary
+                    n = dynamic.check_flow_information(flow_scope, name_str,
+                                                       position)
+                    if n:
+                        result = n
+                        break
+
+                    if result:
+                        break
+                    if flow_scope == nscope:
+                        break
+                    flow_scope = flow_scope.parent
+                flow_scope = nscope
                 if result:
                     break
-                if flow_scope == nscope:
-                    break
-                flow_scope = flow_scope.parent
-            flow_scope = nscope
-            if result:
-                break
 
-        if not result and isinstance(nscope, er.Instance):
-            # __getattr__ / __getattribute__
-            result += check_getattr(nscope, name_str)
-        debug.dbg('sfn filter "%s" in (%s-%s): %s@%s'
-                  % (name_str, scope, nscope, u(result), position))
-        return result
+            if not result and isinstance(nscope, er.Instance):
+                # __getattr__ / __getattribute__
+                result += check_getattr(nscope, name_str)
+            debug.dbg('sfn filter "%s" in (%s-%s): %s@%s'
+                      % (name_str, scope, nscope, u(result), position))
+            return result
 
-    def descriptor_check(result):
-        """Processes descriptors"""
-        res_new = []
-        for r in result:
-            if isinstance(scope, (er.Instance, er.Class)) \
-                    and hasattr(r, 'get_descriptor_return'):
-                # handle descriptors
-                with common.ignored(KeyError):
-                    res_new += r.get_descriptor_return(scope)
-                    continue
-            res_new.append(r)
-        return res_new
+        def descriptor_check(result):
+            """Processes descriptors"""
+            res_new = []
+            for r in result:
+                if isinstance(scope, (er.Instance, er.Class)) \
+                        and hasattr(r, 'get_descriptor_return'):
+                    # handle descriptors
+                    with common.ignored(KeyError):
+                        res_new += r.get_descriptor_return(scope)
+                        continue
+                res_new.append(r)
+            return res_new
 
-    if search_global:
-        scope_generator = get_names_of_scope(scope, position=position)
-    else:
-        if isinstance(scope, er.Instance):
-            scope_generator = scope.scope_generator()
+        if search_global:
+            scope_generator = get_names_of_scope(scope, position=position)
         else:
-            if isinstance(scope, (er.Class, pr.Module)):
-                # classes are only available directly via chaining?
-                # strange stuff...
-                names = scope.get_defined_names()
+            if isinstance(scope, er.Instance):
+                scope_generator = scope.scope_generator()
             else:
-                names = get_defined_names_for_position(scope, position)
-            scope_generator = iter([(scope, names)])
+                if isinstance(scope, (er.Class, pr.Module)):
+                    # classes are only available directly via chaining?
+                    # strange stuff...
+                    names = scope.get_defined_names()
+                else:
+                    names = get_defined_names_for_position(scope, position)
+                scope_generator = iter([(scope, names)])
 
-    if is_goto:
-        return filter_name(scope_generator)
-    return descriptor_check(remove_statements(filter_name(scope_generator)))
+        if is_goto:
+            return filter_name(scope_generator)
+        return descriptor_check(remove_statements(filter_name(scope_generator)))
+
+    @recursion.RecursionDecorator
+    @cache.memoize_default(default=())
+    def follow_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.
+        In case multiple names are defined in the statement, `seek_name` returns
+        the result for this name.
+
+        :param stmt: A `pr.Statement`.
+        :param seek_name: A string.
+        """
+        debug.dbg('follow_stmt %s (%s)' % (stmt, seek_name))
+        commands = stmt.get_commands()
+        debug.dbg('calls: %s' % commands)
+
+        result = self.follow_call_list(commands)
+
+        # Assignment checking is only important if the statement defines multiple
+        # variables.
+        if len(stmt.get_set_vars()) > 1 and seek_name and stmt.assignment_details:
+            new_result = []
+            for ass_commands, op in stmt.assignment_details:
+                new_result += find_assignments(ass_commands[0], result, seek_name)
+            result = new_result
+        return set(result)
+
+    @common.rethrow_uncaught
+    def follow_call_list(self, call_list, follow_array=False):
+        """
+        `call_list` can be either `pr.Array` or `list of list`.
+        It is used to evaluate a two dimensional object, that has calls, arrays and
+        operators in it.
+        """
+        def evaluate_list_comprehension(lc, parent=None):
+            input = lc.input
+            nested_lc = lc.input.token_list[0]
+            if isinstance(nested_lc, pr.ListComprehension):
+                # is nested LC
+                input = nested_lc.stmt
+            module = input.get_parent_until()
+            # create a for loop, which does the same as list comprehensions
+            loop = pr.ForFlow(module, [input], lc.stmt.start_pos, lc.middle, True)
+
+            loop.parent = parent or lc.get_parent_until(pr.IsScope)
+
+            if isinstance(nested_lc, pr.ListComprehension):
+                loop = evaluate_list_comprehension(nested_lc, loop)
+            return loop
+
+        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)
+                                                       for s in call))
+                call_path = call.generate_call_path()
+                next(call_path, None)  # the first one has been used already
+                result += self.follow_paths(call_path, r, call.parent,
+                                            position=call.start_pos)
+            elif isinstance(call, pr.ListComprehension):
+                loop = evaluate_list_comprehension(call)
+                # 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)
+            else:
+                if isinstance(call, pr.Lambda):
+                    result.append(er.Function(call))
+                # With things like params, these can also be functions...
+                elif isinstance(call, pr.Base) and call.isinstance(er.Function,
+                        er.Class, er.Instance, dynamic.ArrayInstance):
+                    result.append(call)
+                # The string tokens are just operations (+, -, etc.)
+                elif not isinstance(call, (str, unicode)):
+                    if isinstance(call, pr.Call) and str(call.name) == 'if':
+                        # Ternary operators.
+                        while True:
+                            try:
+                                call = next(calls_iterator)
+                            except StopIteration:
+                                break
+                            with common.ignored(AttributeError):
+                                if str(call.name) == 'else':
+                                    break
+                        continue
+                    result += self.follow_call(call)
+                elif call == '*':
+                    if [r for r in result if isinstance(r, er.Array)
+                       or isinstance(r, er.Instance)
+                       and str(r.name) == 'str']:
+                        # if it is an iterable, ignore * operations
+                        next(calls_iterator)
+        return set(result)
+
+    def follow_call(self, call):
+        """Follow a call is following a function, variable, string, etc."""
+        path = call.generate_call_path()
+
+        # find the statement of the Scope
+        s = call
+        while not s.parent.isinstance(pr.IsScope):
+            s = s.parent
+        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()`"""
+        current = next(path)
+
+        if isinstance(current, pr.Array):
+            result = [er.Array(current)]
+        else:
+            if isinstance(current, pr.NamePart):
+                # This is the first global lookup.
+                scopes = self.find_name(scope, current, position=position,
+                                        search_global=True)
+            else:
+                # for pr.Literal
+                scopes = self.find_name(builtin.Builtin.scope, current.type_as_string())
+                # Make instances of those number/string objects.
+                scopes = [er.Instance(s, (current.value,)) for s in scopes]
+            result = imports.strip_imports(scopes)
+
+        return self.follow_paths(path, result, scope, position=position)
+
+    def follow_paths(self, path, results, call_scope, position=None):
+        """
+        In each result, `path` must be followed. Copies the path iterator.
+        """
+        results_new = []
+        if results:
+            if len(results) > 1:
+                iter_paths = itertools.tee(path, len(results))
+            else:
+                iter_paths = [path]
+
+            for i, r in enumerate(results):
+                fp = self.follow_path(iter_paths[i], r, call_scope, position=position)
+                if fp is not None:
+                    results_new += fp
+                else:
+                    # This means stop iteration.
+                    return results
+        return results_new
+
+    def follow_path(self, path, scope, call_scope, position=None):
+        """
+        Uses a generator and tries to complete the path, e.g.::
+
+            foo.bar.baz
+
+        `follow_path` is only responsible for completing `.bar.baz`, the rest is
+        done in the `follow_call` function.
+        """
+        # current is either an Array or a Scope.
+        try:
+            current = next(path)
+        except StopIteration:
+            return None
+        debug.dbg('follow %s in scope %s' % (current, scope))
+
+        result = []
+        if isinstance(current, pr.Array):
+            # This must be an execution, either () or [].
+            if current.type == pr.Array.LIST:
+                if hasattr(scope, 'get_index_types'):
+                    result = scope.get_index_types(current)
+            elif current.type not in [pr.Array.DICT]:
+                # Scope must be a class or func - make an instance or execution.
+                debug.dbg('exe', scope)
+                result = er.Execution(scope, current).get_return_types()
+            else:
+                # Curly braces are not allowed, because they make no sense.
+                debug.warning('strange function call with {}', current, scope)
+        else:
+            # The function must not be decorated with something else.
+            if scope.isinstance(er.Function):
+                scope = scope.get_magic_method_scope()
+            else:
+                # This is the typical lookup while chaining things.
+                if filter_private_variable(scope, call_scope, current):
+                    return []
+            result = imports.strip_imports(self.find_name(scope, current,
+                                           position=position))
+        return self.follow_paths(path, set(result), call_scope, position=position)
+
+    def goto(self, stmt, call_path=None):
+        if call_path is None:
+            commands = stmt.get_commands()
+            if len(commands) == 0:
+                return [], ''
+            # Only the first command is important, the rest should basically not
+            # happen except in broken code (e.g. docstrings that aren't code).
+            call = commands[0]
+            if isinstance(call, (str, unicode)):
+                call_path = [call]
+            else:
+                call_path = list(call.generate_call_path())
+
+        scope = stmt.get_parent_until(pr.IsScope)
+        pos = stmt.start_pos
+        call_path, search = call_path[:-1], call_path[-1]
+        pos = pos[0], pos[1] + 1
+
+        if call_path:
+            scopes = self.follow_call_path(iter(call_path), scope, pos)
+            search_global = False
+            pos = None
+        else:
+            scopes = [scope]
+            search_global = True
+        follow_res = []
+        for s in scopes:
+            follow_res += self.find_name(s, search, pos,
+                                         search_global=search_global, is_goto=True)
+        return follow_res, search
+
+
+def filter_private_variable(scope, call_scope, var_name):
+    """private variables begin with a double underline `__`"""
+    if isinstance(var_name, (str, unicode)) and isinstance(scope, er.Instance)\
+            and var_name.startswith('__') and not var_name.endswith('__'):
+        s = call_scope.get_parent_until((pr.Class, er.Instance))
+        if s != scope and s != scope.base.base:
+            return True
+    return False
 
 
 def check_getattr(inst, name_str):
@@ -590,237 +818,3 @@ def find_assignments(lhs, results, seek_name):
         return results
     else:
         return []
-
-
-@recursion.RecursionDecorator
-@cache.memoize_default(default=())
-def follow_statement(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.
-    In case multiple names are defined in the statement, `seek_name` returns
-    the result for this name.
-
-    :param stmt: A `pr.Statement`.
-    :param seek_name: A string.
-    """
-    debug.dbg('follow_stmt %s (%s)' % (stmt, seek_name))
-    commands = stmt.get_commands()
-    debug.dbg('calls: %s' % commands)
-
-    result = follow_call_list(commands)
-
-    # Assignment checking is only important if the statement defines multiple
-    # variables.
-    if len(stmt.get_set_vars()) > 1 and seek_name and stmt.assignment_details:
-        new_result = []
-        for ass_commands, op in stmt.assignment_details:
-            new_result += find_assignments(ass_commands[0], result, seek_name)
-        result = new_result
-    return set(result)
-
-
-@common.rethrow_uncaught
-def follow_call_list(call_list, follow_array=False):
-    """
-    `call_list` can be either `pr.Array` or `list of list`.
-    It is used to evaluate a two dimensional object, that has calls, arrays and
-    operators in it.
-    """
-    def evaluate_list_comprehension(lc, parent=None):
-        input = lc.input
-        nested_lc = lc.input.token_list[0]
-        if isinstance(nested_lc, pr.ListComprehension):
-            # is nested LC
-            input = nested_lc.stmt
-        module = input.get_parent_until()
-        # create a for loop, which does the same as list comprehensions
-        loop = pr.ForFlow(module, [input], lc.stmt.start_pos, lc.middle, True)
-
-        loop.parent = parent or lc.get_parent_until(pr.IsScope)
-
-        if isinstance(nested_lc, pr.ListComprehension):
-            loop = evaluate_list_comprehension(nested_lc, loop)
-        return loop
-
-    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(follow_statement(s)
-                                                   for s in call))
-            call_path = call.generate_call_path()
-            next(call_path, None)  # the first one has been used already
-            result += follow_paths(call_path, r, call.parent,
-                                   position=call.start_pos)
-        elif isinstance(call, pr.ListComprehension):
-            loop = evaluate_list_comprehension(call)
-            # Caveat: parents are being changed, but this doesn't matter,
-            # because nothing else uses it.
-            call.stmt.parent = loop
-            result += follow_statement(call.stmt)
-        else:
-            if isinstance(call, pr.Lambda):
-                result.append(er.Function(call))
-            # With things like params, these can also be functions...
-            elif isinstance(call, pr.Base) and call.isinstance(er.Function,
-                    er.Class, er.Instance, dynamic.ArrayInstance):
-                result.append(call)
-            # The string tokens are just operations (+, -, etc.)
-            elif not isinstance(call, (str, unicode)):
-                if isinstance(call, pr.Call) and str(call.name) == 'if':
-                    # Ternary operators.
-                    while True:
-                        try:
-                            call = next(calls_iterator)
-                        except StopIteration:
-                            break
-                        with common.ignored(AttributeError):
-                            if str(call.name) == 'else':
-                                break
-                    continue
-                result += follow_call(call)
-            elif call == '*':
-                if [r for r in result if isinstance(r, er.Array)
-                   or isinstance(r, er.Instance)
-                   and str(r.name) == 'str']:
-                    # if it is an iterable, ignore * operations
-                    next(calls_iterator)
-    return set(result)
-
-
-def follow_call(call):
-    """Follow a call is following a function, variable, string, etc."""
-    path = call.generate_call_path()
-
-    # find the statement of the Scope
-    s = call
-    while not s.parent.isinstance(pr.IsScope):
-        s = s.parent
-    return follow_call_path(path, s.parent, s.start_pos)
-
-
-def follow_call_path(path, scope, position):
-    """Follows a path generated by `pr.StatementElement.generate_call_path()`"""
-    current = next(path)
-
-    if isinstance(current, pr.Array):
-        result = [er.Array(current)]
-    else:
-        if isinstance(current, pr.NamePart):
-            # This is the first global lookup.
-            scopes = find_name(scope, current, position=position,
-                               search_global=True)
-        else:
-            # for pr.Literal
-            scopes = find_name(builtin.Builtin.scope, current.type_as_string())
-            # Make instances of those number/string objects.
-            scopes = [er.Instance(s, (current.value,)) for s in scopes]
-        result = imports.strip_imports(scopes)
-
-    return follow_paths(path, result, scope, position=position)
-
-
-def follow_paths(path, results, call_scope, position=None):
-    """
-    In each result, `path` must be followed. Copies the path iterator.
-    """
-    results_new = []
-    if results:
-        if len(results) > 1:
-            iter_paths = itertools.tee(path, len(results))
-        else:
-            iter_paths = [path]
-
-        for i, r in enumerate(results):
-            fp = follow_path(iter_paths[i], r, call_scope, position=position)
-            if fp is not None:
-                results_new += fp
-            else:
-                # This means stop iteration.
-                return results
-    return results_new
-
-
-def follow_path(path, scope, call_scope, position=None):
-    """
-    Uses a generator and tries to complete the path, e.g.::
-
-        foo.bar.baz
-
-    `follow_path` is only responsible for completing `.bar.baz`, the rest is
-    done in the `follow_call` function.
-    """
-    # current is either an Array or a Scope.
-    try:
-        current = next(path)
-    except StopIteration:
-        return None
-    debug.dbg('follow %s in scope %s' % (current, scope))
-
-    result = []
-    if isinstance(current, pr.Array):
-        # This must be an execution, either () or [].
-        if current.type == pr.Array.LIST:
-            if hasattr(scope, 'get_index_types'):
-                result = scope.get_index_types(current)
-        elif current.type not in [pr.Array.DICT]:
-            # Scope must be a class or func - make an instance or execution.
-            debug.dbg('exe', scope)
-            result = er.Execution(scope, current).get_return_types()
-        else:
-            # Curly braces are not allowed, because they make no sense.
-            debug.warning('strange function call with {}', current, scope)
-    else:
-        # The function must not be decorated with something else.
-        if scope.isinstance(er.Function):
-            scope = scope.get_magic_method_scope()
-        else:
-            # This is the typical lookup while chaining things.
-            if filter_private_variable(scope, call_scope, current):
-                return []
-        result = imports.strip_imports(find_name(scope, current,
-                                                 position=position))
-    return follow_paths(path, set(result), call_scope, position=position)
-
-
-def filter_private_variable(scope, call_scope, var_name):
-    """private variables begin with a double underline `__`"""
-    if isinstance(var_name, (str, unicode)) and isinstance(scope, er.Instance)\
-            and var_name.startswith('__') and not var_name.endswith('__'):
-        s = call_scope.get_parent_until((pr.Class, er.Instance))
-        if s != scope and s != scope.base.base:
-            return True
-    return False
-
-
-def goto(stmt, call_path=None):
-    if call_path is None:
-        commands = stmt.get_commands()
-        if len(commands) == 0:
-            return [], ''
-        # Only the first command is important, the rest should basically not
-        # happen except in broken code (e.g. docstrings that aren't code).
-        call = commands[0]
-        if isinstance(call, (str, unicode)):
-            call_path = [call]
-        else:
-            call_path = list(call.generate_call_path())
-
-    scope = stmt.get_parent_until(pr.IsScope)
-    pos = stmt.start_pos
-    call_path, search = call_path[:-1], call_path[-1]
-    pos = pos[0], pos[1] + 1
-
-    if call_path:
-        scopes = follow_call_path(iter(call_path), scope, pos)
-        search_global = False
-        pos = None
-    else:
-        scopes = [scope]
-        search_global = True
-    follow_res = []
-    for s in scopes:
-        follow_res += find_name(s, search, pos,
-                                search_global=search_global, is_goto=True)
-    return follow_res, search

From 65013d10194ddd9d66ef42bb46089173fec19701 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 15:24:37 +0100
Subject: [PATCH 03/42] add an execute method to the evaluator

---
 jedi/evaluate/__init__.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 0d7cf306..e8ac63c5 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -642,7 +642,7 @@ class Evaluator(object):
             elif current.type not in [pr.Array.DICT]:
                 # Scope must be a class or func - make an instance or execution.
                 debug.dbg('exe', scope)
-                result = er.Execution(scope, current).get_return_types()
+                result = self.execute(scope, current)
             else:
                 # Curly braces are not allowed, because they make no sense.
                 debug.warning('strange function call with {}', current, scope)
@@ -658,6 +658,9 @@ class Evaluator(object):
                                            position=position))
         return self.follow_paths(path, set(result), call_scope, position=position)
 
+    def execute(self, scope, params):
+        return er.Execution(scope, params).get_return_types()
+
     def goto(self, stmt, call_path=None):
         if call_path is None:
             commands = stmt.get_commands()

From ae17c661483f0b9f57b87e7152b1a406992f575f Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 15:38:40 +0100
Subject: [PATCH 04/42] use evaluator everywhere in representation

---
 jedi/evaluate/__init__.py       |  4 ++--
 jedi/evaluate/representation.py | 38 ++++++++++++++++++---------------
 2 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index e8ac63c5..80a86f6d 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -658,8 +658,8 @@ class Evaluator(object):
                                            position=position))
         return self.follow_paths(path, set(result), call_scope, position=position)
 
-    def execute(self, scope, params):
-        return er.Execution(scope, params).get_return_types()
+    def execute(self, scope, params, evaluate_generator=False):
+        return er.Execution(scope, params).get_return_types(evaluate_generator)
 
     def goto(self, stmt, call_path=None):
         if call_path is None:
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index c5b63fca..afb63f56 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -32,7 +32,8 @@ class Executable(pr.IsScope):
     An instance is also an executable - because __init__ is called
     :param var_args: The param input array, consist of `pr.Array` or list.
     """
-    def __init__(self, base, var_args=()):
+    def __init__(self, evaluator, base, var_args=()):
+        self.evaluator = evaluator
         self.base = base
         self.var_args = var_args
 
@@ -55,8 +56,8 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
     """
     This class is used to evaluate instances.
     """
-    def __init__(self, base, var_args=()):
-        super(Instance, self).__init__(base, var_args)
+    def __init__(self, evaluator, base, var_args=()):
+        super(Instance, self).__init__(evaluator, base, var_args)
         if str(base.name) in ['list', 'set'] \
                 and builtin.Builtin.scope == base.get_parent_until():
             # compare the module path with the builtin name.
@@ -249,7 +250,8 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     This class is not only important to extend `pr.Class`, it is also a
     important for descriptors (if the descriptor methods are evaluated or not).
     """
-    def __init__(self, base):
+    def __init__(self, evaluator, base):
+        self.evaluator = evaluator
         self.base = base
 
     @cache.memoize_default(default=())
@@ -258,14 +260,14 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         # TODO care for mro stuff (multiple super classes).
         for s in self.base.supers:
             # Super classes are statements.
-            for cls in evaluate.follow_statement(s):
+            for cls in self.evaluator.follow_statement(s):
                 if not isinstance(cls, Class):
                     debug.warning('Received non class, as a super class')
                     continue  # Just ignore other stuff (user input error).
                 supers.append(cls)
         if not supers and self.base.parent != builtin.Builtin.scope:
             # add `object` to classes
-            supers += evaluate.find_name(builtin.Builtin.scope, 'object')
+            supers += self.evaluator.find_name(builtin.Builtin.scope, 'object')
         return supers
 
     @cache.memoize_default(default=())
@@ -293,7 +295,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     @cache.memoize_default(default=())
     def get_defined_names(self):
         result = self.instance_names()
-        type_cls = evaluate.find_name(builtin.Builtin.scope, 'type')[0]
+        type_cls = self.evaluator.find_name(builtin.Builtin.scope, 'type')[0]
         return result + type_cls.base.get_defined_names()
 
     def get_subscope_by_name(self, name):
@@ -321,8 +323,9 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     """
     Needed because of decorators. Decorators are evaluated here.
     """
-    def __init__(self, func, is_decorated=False):
+    def __init__(self, evaluator, func, is_decorated=False):
         """ This should not be called directly """
+        self.evaluator = evaluator
         self.base_func = func
         self.is_decorated = is_decorated
 
@@ -338,7 +341,7 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         if not self.is_decorated:
             for dec in reversed(self.base_func.decorators):
                 debug.dbg('decorator:', dec, f)
-                dec_results = set(evaluate.follow_statement(dec))
+                dec_results = set(self.evaluator.follow_statement(dec))
                 if not len(dec_results):
                     debug.warning('decorator not found: %s on %s' %
                                  (dec, self.base_func))
@@ -411,7 +414,7 @@ class Execution(Executable):
             return []
         else:
             if isinstance(stmt, pr.Statement):
-                return evaluate.follow_statement(stmt)
+                return self.evaluator.follow_statement(stmt)
             else:
                 return [stmt]  # just some arbitrary object
 
@@ -451,7 +454,7 @@ class Execution(Executable):
                         if len(arr_name.var_args) != 1:
                             debug.warning('jedi getattr is too simple')
                         key = arr_name.var_args[0]
-                        stmts += evaluate.follow_path(iter([key]), obj, base)
+                        stmts += self.evaluator.follow_path(iter([key]), obj, base)
                 return stmts
             elif func_name == 'type':
                 # otherwise it would be a metaclass
@@ -507,7 +510,7 @@ class Execution(Executable):
             stmts = docstrings.find_return_types(func)
             for r in self.returns:
                 if r is not None:
-                    stmts += evaluate.follow_statement(r)
+                    stmts += self.evaluator.follow_statement(r)
             return stmts
 
     @cache.memoize_default(default=())
@@ -662,7 +665,7 @@ class Execution(Executable):
                 if not len(commands):
                     continue
                 if commands[0] == '*':
-                    arrays = evaluate.follow_call_list(commands[1:])
+                    arrays = self.evaluator.follow_call_list(commands[1:])
                     # *args must be some sort of an array, otherwise -> ignore
 
                     for array in arrays:
@@ -674,7 +677,7 @@ class Execution(Executable):
                                 yield None, helpers.FakeStatement(field_stmt)
                 # **kwargs
                 elif commands[0] == '**':
-                    arrays = evaluate.follow_call_list(commands[1:])
+                    arrays = self.evaluator.follow_call_list(commands[1:])
                     for array in arrays:
                         if isinstance(array, Array):
                             for key_stmt, value_stmt in array.items():
@@ -826,7 +829,8 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base)):
     Used as a mirror to pr.Array, if needed. It defines some getter
     methods which are important in this module.
     """
-    def __init__(self, array):
+    def __init__(self, evaluator, array):
+        self.evaluator = evaluator
         self._array = array
 
     def get_index_types(self, index_arr=None):
@@ -882,7 +886,7 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base)):
 
     def _follow_values(self, values):
         """ helper function for the index getters """
-        return list(itertools.chain.from_iterable(evaluate.follow_statement(v)
+        return list(itertools.chain.from_iterable(self.evaluator.follow_statement(v)
                                                   for v in values))
 
     def get_defined_names(self):
@@ -891,7 +895,7 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base)):
         It returns e.g. for a list: append, pop, ...
         """
         # `array.type` is a string with the type, e.g. 'list'.
-        scope = evaluate.find_name(builtin.Builtin.scope, self._array.type)[0]
+        scope = self.evaluator.find_name(builtin.Builtin.scope, self._array.type)[0]
         scope = Instance(scope)
         names = scope.get_defined_names()
         return [ArrayMethod(n) for n in names]

From 28771b8f1576248b56d9bfc67cc0a020be2d6745 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 15:50:15 +0100
Subject: [PATCH 05/42] remove import problems - evaluate calls from a lot of
 places

---
 jedi/api_classes.py | 2 +-
 jedi/builtin.py     | 1 -
 jedi/docstrings.py  | 2 --
 jedi/dynamic.py     | 3 ---
 jedi/recursion.py   | 1 -
 5 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index f2fb1a5c..67582625 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -14,7 +14,7 @@ from jedi import common
 from jedi.parser import representation as pr
 from jedi import cache
 from jedi import evaluate
-from jedi import representation as er
+from jedi.evaluate import representation as er
 import keywords
 import recursion
 import dynamic
diff --git a/jedi/builtin.py b/jedi/builtin.py
index 85f1f745..4fa7ce04 100644
--- a/jedi/builtin.py
+++ b/jedi/builtin.py
@@ -36,7 +36,6 @@ from jedi import common
 from jedi import debug
 from jedi.parser import Parser
 from jedi import modules
-import evaluate
 
 
 class BuiltinModule(modules.CachedModule):
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 4ae7c842..3ccc506d 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -18,8 +18,6 @@ import re
 
 from jedi import cache
 from jedi.parser import Parser
-from jedi import evaluate
-from jedi.evaluate import representation as er
 
 DOCSTRING_PARAM_PATTERNS = [
     r'\s*:type\s+%s:\s*([^\n]+)',  # Sphinx
diff --git a/jedi/dynamic.py b/jedi/dynamic.py
index 03ac5634..e62f736f 100644
--- a/jedi/dynamic.py
+++ b/jedi/dynamic.py
@@ -62,10 +62,7 @@ from jedi import settings
 from jedi import common
 from jedi import debug
 from jedi.parser import fast as fast_parser
-import api_classes
-import evaluate
 import imports
-import evaluate_representation as er
 
 # This is something like the sys.path, but only for searching params. It means
 # that this is the order in which Jedi searches params.
diff --git a/jedi/recursion.py b/jedi/recursion.py
index da083372..b704856e 100644
--- a/jedi/recursion.py
+++ b/jedi/recursion.py
@@ -10,7 +10,6 @@ calls.
 from jedi.parser import representation as pr
 from jedi import debug
 from jedi import settings
-from jedi.evaluate import representation as er
 import builtin
 
 

From b9719b8c13e6bde4227e1019d2b6b4d09bde553d Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 16:05:43 +0100
Subject: [PATCH 06/42] first tests running again with the new structure

---
 jedi/api.py               | 21 +++++++++++----------
 jedi/api_classes.py       |  1 -
 jedi/evaluate/__init__.py |  6 +++---
 jedi/recursion.py         |  4 ++--
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index 7d369f86..b4c7c13c 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -25,7 +25,7 @@ from jedi import cache
 from jedi import modules
 from jedi import interpret
 from jedi._compatibility import next, unicode, builtins
-from jedi import evaluate
+from jedi.evaluate import Evaluator
 from jedi.evaluate import representation as er
 import keywords
 import api_classes
@@ -82,7 +82,7 @@ class Script(object):
         if not (0 <= self._column <= line_len):
             raise ValueError('`column` parameter is not in a valid range.')
 
-        api_classes._clear_caches()
+        #api_classes._clear_caches()  # TODO REMOVE
         debug.reset_time()
         self.source = modules.source_to_unicode(source, encoding)
         self._pos = self._line, self._column
@@ -90,6 +90,7 @@ class Script(object):
             path, source=self.source, position=self._pos)
         self._source_path = path
         self.path = None if path is None else os.path.abspath(path)
+        self._evaluator = Evaluator()
         debug.speed('init')
 
     @property
@@ -110,7 +111,7 @@ class Script(object):
         """ lazy parser."""
         return self._module.parser
 
-    @api_classes._clear_caches_after_call
+    #@api_classes._clear_caches_after_call
     def completions(self):
         """
         Return :class:`api_classes.Completion` objects. Those objects contain
@@ -242,7 +243,7 @@ class Script(object):
         else:
             # just parse one statement, take it and evaluate it
             stmt = self._get_under_cursor_stmt(goto_path)
-            scopes = evaluate.follow_statement(stmt)
+            scopes = self._evaluator.follow_statement(stmt)
         return scopes
 
     def _get_under_cursor_stmt(self, cursor_txt):
@@ -318,7 +319,7 @@ class Script(object):
         sig = self.call_signatures()
         return sig[0] if sig else None
 
-    @api_classes._clear_caches_after_call
+    #@api_classes._clear_caches_after_call
     def goto_definitions(self):
         """
         Return the definitions of a the path under the cursor.  goto function!
@@ -382,7 +383,7 @@ class Script(object):
                  if s is not imports.ImportPath.GlobalNamespace])
         return self._sorted_defs(d)
 
-    @api_classes._clear_caches_after_call
+    #@api_classes._clear_caches_after_call
     def goto_assignments(self):
         """
         Return the first definition found. Imports and statements aren't
@@ -440,7 +441,7 @@ class Script(object):
                     definitions.append(import_name[0])
         else:
             stmt = self._get_under_cursor_stmt(goto_path)
-            defs, search_name = evaluate.goto(stmt)
+            defs, search_name = self._evaluator.goto(stmt)
             definitions = follow_inexistent_imports(defs)
             if isinstance(user_stmt, pr.Statement):
                 c = user_stmt.get_commands()
@@ -452,7 +453,7 @@ class Script(object):
                     definitions = [user_stmt]
         return definitions, search_name
 
-    @api_classes._clear_caches_after_call
+    #@api_classes._clear_caches_after_call
     def usages(self, additional_module_paths=()):
         """
         Return :class:`api_classes.Usage` objects, which contain all
@@ -496,7 +497,7 @@ class Script(object):
         settings.dynamic_flow_information = temp
         return self._sorted_defs(set(names))
 
-    @api_classes._clear_caches_after_call
+    #@api_classes._clear_caches_after_call
     def call_signatures(self):
         """
         Return the function object of the call you're currently in.
@@ -520,7 +521,7 @@ class Script(object):
 
         user_stmt = self._user_stmt()
         with common.scale_speed_settings(settings.scale_call_signatures):
-            _callable = lambda: evaluate.follow_call(call)
+            _callable = lambda: self._evaluator.follow_call(call)
             origins = cache.cache_call_signatures(_callable, user_stmt)
         debug.speed('func_call followed')
 
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index 67582625..6eb8dca7 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -13,7 +13,6 @@ from jedi import settings
 from jedi import common
 from jedi.parser import representation as pr
 from jedi import cache
-from jedi import evaluate
 from jedi.evaluate import representation as er
 import keywords
 import recursion
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 80a86f6d..0a126423 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -287,9 +287,9 @@ class Evaluator(object):
                     res_new += add
                 else:
                     if isinstance(r, pr.Class):
-                        r = er.Class(r)
+                        r = er.Class(self, r)
                     elif isinstance(r, pr.Function):
-                        r = er.Function(r)
+                        r = er.Function(self, r)
                     if r.isinstance(er.Function) and resolve_decorator:
                         r = r.get_decorated_func()
                     res_new.append(r)
@@ -472,8 +472,8 @@ class Evaluator(object):
             return filter_name(scope_generator)
         return descriptor_check(remove_statements(filter_name(scope_generator)))
 
-    @recursion.RecursionDecorator
     @cache.memoize_default(default=())
+    @recursion.RecursionDecorator
     def follow_statement(self, stmt, seek_name=None):
         """
         The starting point of the completion. A statement always owns a call list,
diff --git a/jedi/recursion.py b/jedi/recursion.py
index b704856e..41e22d3d 100644
--- a/jedi/recursion.py
+++ b/jedi/recursion.py
@@ -22,12 +22,12 @@ class RecursionDecorator(object):
         self.func = func
         self.reset()
 
-    def __call__(self, stmt, *args, **kwargs):
+    def __call__(self, evaluator, stmt, *args, **kwargs):
         # print stmt, len(self.node_statements())
         if self.push_stmt(stmt):
             return []
         else:
-            result = self.func(stmt, *args, **kwargs)
+            result = self.func(evaluator, stmt, *args, **kwargs)
             self.pop_stmt()
         return result
 

From 4e68856cc448031deef651e86626f3f2e9a32de1 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 16:12:07 +0100
Subject: [PATCH 07/42] move builtin and imports into the evaluate directory

---
 jedi/api.py                    | 6 +++---
 jedi/api_classes.py            | 4 ++--
 jedi/dynamic.py                | 2 +-
 jedi/{ => evaluate}/builtin.py | 0
 jedi/{ => evaluate}/imports.py | 2 +-
 jedi/keywords.py               | 2 +-
 jedi/recursion.py              | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)
 rename jedi/{ => evaluate}/builtin.py (100%)
 rename jedi/{ => evaluate}/imports.py (99%)

diff --git a/jedi/api.py b/jedi/api.py
index b4c7c13c..9dd49bad 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -27,11 +27,11 @@ from jedi import interpret
 from jedi._compatibility import next, unicode, builtins
 from jedi.evaluate import Evaluator
 from jedi.evaluate import representation as er
-import keywords
+from jedi import keywords
+from jedi.evaluate import builtin
+from jedi.evaluate import imports
 import api_classes
 import dynamic
-import imports
-import builtin
 
 
 class NotFoundError(Exception):
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index 6eb8dca7..45573f2f 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -14,10 +14,10 @@ from jedi import common
 from jedi.parser import representation as pr
 from jedi import cache
 from jedi.evaluate import representation as er
-import keywords
+from jedi.evaluate import imports
+from jedi import keywords
 import recursion
 import dynamic
-import imports
 
 
 def _clear_caches():
diff --git a/jedi/dynamic.py b/jedi/dynamic.py
index e62f736f..3d59c403 100644
--- a/jedi/dynamic.py
+++ b/jedi/dynamic.py
@@ -62,7 +62,7 @@ from jedi import settings
 from jedi import common
 from jedi import debug
 from jedi.parser import fast as fast_parser
-import imports
+from jedi.evaluate import imports
 
 # This is something like the sys.path, but only for searching params. It means
 # that this is the order in which Jedi searches params.
diff --git a/jedi/builtin.py b/jedi/evaluate/builtin.py
similarity index 100%
rename from jedi/builtin.py
rename to jedi/evaluate/builtin.py
diff --git a/jedi/imports.py b/jedi/evaluate/imports.py
similarity index 99%
rename from jedi/imports.py
rename to jedi/evaluate/imports.py
index a28b94e0..4c646e5b 100644
--- a/jedi/imports.py
+++ b/jedi/evaluate/imports.py
@@ -24,7 +24,7 @@ from jedi import common
 from jedi import debug
 from jedi.parser import representation as pr
 from jedi import cache
-import builtin
+from jedi.evaluate import builtin
 
 # for debugging purposes only
 imports_processed = 0
diff --git a/jedi/keywords.py b/jedi/keywords.py
index 23f2ffb6..19abde64 100644
--- a/jedi/keywords.py
+++ b/jedi/keywords.py
@@ -6,7 +6,7 @@ import keyword
 from jedi._compatibility import is_py3k
 from jedi.parser import representation as pr
 from jedi import common
-import builtin
+from jedi.evaluate import builtin
 
 try:
     from pydoc_data import topics as pydoc_topics
diff --git a/jedi/recursion.py b/jedi/recursion.py
index 41e22d3d..d9407e51 100644
--- a/jedi/recursion.py
+++ b/jedi/recursion.py
@@ -10,7 +10,7 @@ calls.
 from jedi.parser import representation as pr
 from jedi import debug
 from jedi import settings
-import builtin
+from jedi.evaluate import builtin
 
 
 class RecursionDecorator(object):

From 7bf6ff768c8332fa1c957ef9445ca0bb3dd9054c Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 16:22:48 +0100
Subject: [PATCH 08/42] first steps to world domination -> removal of the
 hackish sys.path modifications

---
 jedi/__init__.py                | 8 --------
 jedi/common.py                  | 2 +-
 jedi/evaluate/__init__.py       | 4 ++--
 jedi/evaluate/representation.py | 4 ++--
 jedi/parser/__init__.py         | 2 +-
 jedi/{ => parser}/tokenizer.py  | 0
 6 files changed, 6 insertions(+), 14 deletions(-)
 rename jedi/{ => parser}/tokenizer.py (100%)

diff --git a/jedi/__init__.py b/jedi/__init__.py
index 73516c6f..4763d6c4 100644
--- a/jedi/__init__.py
+++ b/jedi/__init__.py
@@ -36,14 +36,6 @@ good text editor, while still having very good IDE features for Python.
 
 __version__ = 0, 7, 1, 'alpha1'
 
-import sys
-
-# python imports are hell sometimes. Especially the combination of relative
-# imports and circular imports... Just avoid it:
-sys.path.insert(0, __path__[0])
-
 from .api import Script, Interpreter, NotFoundError, set_debug_function
 from .api import preload_module, defined_names
 from . import settings
-
-sys.path.pop(0)
diff --git a/jedi/common.py b/jedi/common.py
index 929c8497..48592585 100644
--- a/jedi/common.py
+++ b/jedi/common.py
@@ -2,8 +2,8 @@
 import sys
 import contextlib
 import functools
-import tokenizer as tokenize
 
+from jedi.parser import tokenizer as tokenize
 from jedi._compatibility import next, reraise
 from jedi import settings
 
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 0a126423..bdee12fd 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -79,10 +79,10 @@ from jedi import cache
 from jedi.parser import representation as pr
 from jedi import debug
 from jedi.evaluate import representation as er
+from jedi.evaluate import builtin
+from jedi.evaluate import imports
 import recursion
 import docstrings
-import builtin
-import imports
 import dynamic
 
 
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index afb63f56..2cb08c53 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -20,10 +20,10 @@ from jedi import cache
 from jedi import helpers
 from jedi import debug
 from jedi import common
+from jedi.evaluate import imports
+from jedi.evaluate import builtin
 import recursion
 import docstrings
-import imports
-import builtin
 import dynamic
 
 
diff --git a/jedi/parser/__init__.py b/jedi/parser/__init__.py
index 3e6c7f9c..93b6ecd0 100644
--- a/jedi/parser/__init__.py
+++ b/jedi/parser/__init__.py
@@ -17,7 +17,6 @@ complexity of the ``Parser`` (there's another parser sitting inside
 """
 from __future__ import with_statement
 
-import tokenizer as tokenize
 import keyword
 
 from jedi._compatibility import next, StringIO
@@ -25,6 +24,7 @@ from jedi import debug
 from jedi import common
 from jedi.parser import representation as pr
 from jedi.parser import token as token_pr
+from jedi.parser import tokenizer as tokenize
 
 
 class Parser(object):
diff --git a/jedi/tokenizer.py b/jedi/parser/tokenizer.py
similarity index 100%
rename from jedi/tokenizer.py
rename to jedi/parser/tokenizer.py

From cf4b2c4557c25ebe0a58a50aaad2f327aad79771 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 16:28:28 +0100
Subject: [PATCH 09/42] the whole import thing seems to be working

---
 jedi/evaluate/__init__.py       | 6 +++---
 jedi/evaluate/representation.py | 6 +++---
 jedi/modules.py                 | 2 +-
 jedi/parser/tokenizer.py        | 1 +
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index bdee12fd..8e404a41 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -81,9 +81,9 @@ from jedi import debug
 from jedi.evaluate import representation as er
 from jedi.evaluate import builtin
 from jedi.evaluate import imports
-import recursion
-import docstrings
-import dynamic
+from jedi import recursion
+from jedi import docstrings
+from jedi import dynamic
 
 
 def get_defined_names_for_position(scope, position=None, start_scope=None):
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 2cb08c53..069d7980 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -22,9 +22,9 @@ from jedi import debug
 from jedi import common
 from jedi.evaluate import imports
 from jedi.evaluate import builtin
-import recursion
-import docstrings
-import dynamic
+from jedi import recursion
+from jedi import docstrings
+from jedi import dynamic
 
 
 class Executable(pr.IsScope):
diff --git a/jedi/modules.py b/jedi/modules.py
index 4baaf1b6..c603f772 100644
--- a/jedi/modules.py
+++ b/jedi/modules.py
@@ -16,7 +16,6 @@ Apart from those classes there's a ``sys.path`` fetching function, as well as
 from __future__ import with_statement
 
 import re
-import tokenizer as tokenize
 import sys
 import os
 from ast import literal_eval
@@ -24,6 +23,7 @@ from ast import literal_eval
 from jedi._compatibility import exec_function, unicode
 from jedi import cache
 from jedi.parser import representation as pr
+from jedi.parser import tokenizer as tokenize
 from jedi.parser import fast
 from jedi import debug
 from jedi import common
diff --git a/jedi/parser/tokenizer.py b/jedi/parser/tokenizer.py
index ea81eefd..689a3e43 100644
--- a/jedi/parser/tokenizer.py
+++ b/jedi/parser/tokenizer.py
@@ -8,6 +8,7 @@ Basically this is a stripped down version of the standard library module, so
 you can read the documentation there.
 """
 
+from __future__ import absolute_import
 import string
 import re
 from token import *

From cd8880d8ef049ae641036c226f323f674abc733c Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 17:19:07 +0100
Subject: [PATCH 10/42] move recursion.py to evaluate folder

---
 jedi/api_classes.py              | 5 +----
 jedi/evaluate/__init__.py        | 2 +-
 jedi/{ => evaluate}/recursion.py | 0
 jedi/evaluate/representation.py  | 2 +-
 4 files changed, 3 insertions(+), 6 deletions(-)
 rename jedi/{ => evaluate}/recursion.py (100%)

diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index 45573f2f..af9a4737 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -3,8 +3,6 @@ The :mod:`api_classes` module contains the return classes of the API. These
 classes are the much bigger part of the whole API, because they contain the
 interesting information about completion and goto operations.
 """
-from __future__ import with_statement
-
 import warnings
 import functools
 
@@ -16,7 +14,6 @@ from jedi import cache
 from jedi.evaluate import representation as er
 from jedi.evaluate import imports
 from jedi import keywords
-import recursion
 import dynamic
 
 
@@ -27,7 +24,7 @@ def _clear_caches():
     """
     cache.clear_caches()
     dynamic.search_param_cache.clear()
-    recursion.ExecutionRecursionDecorator.reset()
+    #recursion.ExecutionRecursionDecorator.reset()
 
     evaluate.follow_statement.reset()
 
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 8e404a41..9204482f 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -81,7 +81,7 @@ from jedi import debug
 from jedi.evaluate import representation as er
 from jedi.evaluate import builtin
 from jedi.evaluate import imports
-from jedi import recursion
+from jedi.evaluate import recursion
 from jedi import docstrings
 from jedi import dynamic
 
diff --git a/jedi/recursion.py b/jedi/evaluate/recursion.py
similarity index 100%
rename from jedi/recursion.py
rename to jedi/evaluate/recursion.py
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 069d7980..3ef1f4f1 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -22,7 +22,7 @@ from jedi import debug
 from jedi import common
 from jedi.evaluate import imports
 from jedi.evaluate import builtin
-from jedi import recursion
+from jedi.evaluate import recursion
 from jedi import docstrings
 from jedi import dynamic
 

From eedadbfe9588c90e8d7681295bc9d7d7a7898209 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 17:27:06 +0100
Subject: [PATCH 11/42] temporary interfaces subclass. let's see if we need to
 keep it

---
 jedi/evaluate/interfaces.py     | 3 +++
 jedi/evaluate/recursion.py      | 3 ++-
 jedi/evaluate/representation.py | 5 +++--
 3 files changed, 8 insertions(+), 3 deletions(-)
 create mode 100644 jedi/evaluate/interfaces.py

diff --git a/jedi/evaluate/interfaces.py b/jedi/evaluate/interfaces.py
new file mode 100644
index 00000000..cee5b244
--- /dev/null
+++ b/jedi/evaluate/interfaces.py
@@ -0,0 +1,3 @@
+class Iterable():
+    """Parent class of Generator and Array, exists due to import restrictions."""
+    pass
diff --git a/jedi/evaluate/recursion.py b/jedi/evaluate/recursion.py
index d9407e51..baa1bc9d 100644
--- a/jedi/evaluate/recursion.py
+++ b/jedi/evaluate/recursion.py
@@ -11,6 +11,7 @@ from jedi.parser import representation as pr
 from jedi import debug
 from jedi import settings
 from jedi.evaluate import builtin
+from jedi.evaluate import interfaces
 
 
 class RecursionDecorator(object):
@@ -131,7 +132,7 @@ class ExecutionRecursionDecorator(object):
         if cls.execution_count > settings.max_executions:
             return True
 
-        if isinstance(execution.base, (er.Generator, er.Array)):
+        if isinstance(execution.base, interfaces.Iterable):
             return False
         module = execution.get_parent_until()
         if evaluate_generator or module == builtin.Builtin.scope:
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 3ef1f4f1..983efb0c 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -25,6 +25,7 @@ from jedi.evaluate import builtin
 from jedi.evaluate import recursion
 from jedi import docstrings
 from jedi import dynamic
+from jedi.evaluate.interfaces import Iterable
 
 
 class Executable(pr.IsScope):
@@ -778,7 +779,7 @@ class Execution(Executable):
             (type(self).__name__, self._decorated)
 
 
-class Generator(use_metaclass(cache.CachedMetaClass, pr.Base)):
+class Generator(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
     """ Cares for `yield` statements. """
     def __init__(self, func, var_args):
         super(Generator, self).__init__()
@@ -824,7 +825,7 @@ class Generator(use_metaclass(cache.CachedMetaClass, pr.Base)):
         return "<%s of %s>" % (type(self).__name__, self.func)
 
 
-class Array(use_metaclass(cache.CachedMetaClass, pr.Base)):
+class Array(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
     """
     Used as a mirror to pr.Array, if needed. It defines some getter
     methods which are important in this module.

From d25cc6e1febc49ecfd0bbb502bbe941024c01391 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 17:52:01 +0100
Subject: [PATCH 12/42] it should be _evaluator not evaluator

---
 jedi/evaluate/__init__.py       |  3 +++
 jedi/evaluate/imports.py        | 16 ++++++++--------
 jedi/evaluate/representation.py | 28 ++++++++++++++--------------
 3 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 9204482f..32766952 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -203,6 +203,9 @@ def get_names_of_scope(scope, position=None, star_search=True,
 
 
 class Evaluator(object):
+    def __init__(self):
+        self.cache = None
+
     def find_name(self, scope, name_str, position=None, search_global=False,
                   is_goto=False, resolve_decorator=True):
         """
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index 4c646e5b..2c95e521 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -130,9 +130,9 @@ class ImportPath(pr.Base):
                         # ``sys.modules`` modification.
                         p = (0, 0)
                         names.append(pr.Name(self.GlobalNamespace, [('path', p)],
-                                       p, p, self.import_stmt))
+                                     p, p, self.import_stmt))
                     continue
-                for s, scope_names in evaluate.get_names_of_scope(scope,
+                for s, scope_names in self._evaluator.get_names_of_scope(scope,
                                                                   include_builtin=False):
                     for n in scope_names:
                         if self.import_stmt.from_ns is None \
@@ -186,7 +186,7 @@ class ImportPath(pr.Base):
         """
         Returns the imported modules.
         """
-        if evaluate.follow_statement.push_stmt(self.import_stmt):
+        if self._evaluator.follow_statement.push_stmt(self.import_stmt):
             # check recursion
             return []
 
@@ -195,7 +195,7 @@ class ImportPath(pr.Base):
                 scope, rest = self._follow_file_system()
             except ModuleNotFound:
                 debug.warning('Module not found: ' + str(self.import_stmt))
-                evaluate.follow_statement.pop_stmt()
+                self._evaluator.follow_statement.pop_stmt()
                 return []
 
             scopes = [scope]
@@ -210,15 +210,15 @@ class ImportPath(pr.Base):
                     # ``os.path``, because it's a very important one in Python
                     # that is being achieved by messing with ``sys.modules`` in
                     # ``os``.
-                    scopes = evaluate.follow_path(iter(rest), scope, scope)
+                    scopes = self._evaluator.follow_path(iter(rest), scope, scope)
             elif rest:
                 if is_goto:
                     scopes = itertools.chain.from_iterable(
-                        evaluate.find_name(s, rest[0], is_goto=True)
+                        self._evaluator.find_name(s, rest[0], is_goto=True)
                         for s in scopes)
                 else:
                     scopes = itertools.chain.from_iterable(
-                        evaluate.follow_path(iter(rest), s, s)
+                        self._evaluator.follow_path(iter(rest), s, s)
                         for s in scopes)
             scopes = list(scopes)
 
@@ -228,7 +228,7 @@ class ImportPath(pr.Base):
             scopes = [ImportPath.GlobalNamespace]
         debug.dbg('after import', scopes)
 
-        evaluate.follow_statement.pop_stmt()
+        self._evaluator.follow_statement.pop_stmt()
         return scopes
 
     def _is_relative_import(self):
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 983efb0c..11a3914b 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -252,7 +252,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     important for descriptors (if the descriptor methods are evaluated or not).
     """
     def __init__(self, evaluator, base):
-        self.evaluator = evaluator
+        self._evaluator = evaluator
         self.base = base
 
     @cache.memoize_default(default=())
@@ -261,14 +261,14 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         # TODO care for mro stuff (multiple super classes).
         for s in self.base.supers:
             # Super classes are statements.
-            for cls in self.evaluator.follow_statement(s):
+            for cls in self._evaluator.follow_statement(s):
                 if not isinstance(cls, Class):
                     debug.warning('Received non class, as a super class')
                     continue  # Just ignore other stuff (user input error).
                 supers.append(cls)
         if not supers and self.base.parent != builtin.Builtin.scope:
             # add `object` to classes
-            supers += self.evaluator.find_name(builtin.Builtin.scope, 'object')
+            supers += self._evaluator.find_name(builtin.Builtin.scope, 'object')
         return supers
 
     @cache.memoize_default(default=())
@@ -296,7 +296,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     @cache.memoize_default(default=())
     def get_defined_names(self):
         result = self.instance_names()
-        type_cls = self.evaluator.find_name(builtin.Builtin.scope, 'type')[0]
+        type_cls = self._evaluator.find_name(builtin.Builtin.scope, 'type')[0]
         return result + type_cls.base.get_defined_names()
 
     def get_subscope_by_name(self, name):
@@ -326,7 +326,7 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
     """
     def __init__(self, evaluator, func, is_decorated=False):
         """ This should not be called directly """
-        self.evaluator = evaluator
+        self._evaluator = evaluator
         self.base_func = func
         self.is_decorated = is_decorated
 
@@ -342,7 +342,7 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         if not self.is_decorated:
             for dec in reversed(self.base_func.decorators):
                 debug.dbg('decorator:', dec, f)
-                dec_results = set(self.evaluator.follow_statement(dec))
+                dec_results = set(self._evaluator.follow_statement(dec))
                 if not len(dec_results):
                     debug.warning('decorator not found: %s on %s' %
                                  (dec, self.base_func))
@@ -415,7 +415,7 @@ class Execution(Executable):
             return []
         else:
             if isinstance(stmt, pr.Statement):
-                return self.evaluator.follow_statement(stmt)
+                return self._evaluator.follow_statement(stmt)
             else:
                 return [stmt]  # just some arbitrary object
 
@@ -455,7 +455,7 @@ class Execution(Executable):
                         if len(arr_name.var_args) != 1:
                             debug.warning('jedi getattr is too simple')
                         key = arr_name.var_args[0]
-                        stmts += self.evaluator.follow_path(iter([key]), obj, base)
+                        stmts += self._evaluator.follow_path(iter([key]), obj, base)
                 return stmts
             elif func_name == 'type':
                 # otherwise it would be a metaclass
@@ -511,7 +511,7 @@ class Execution(Executable):
             stmts = docstrings.find_return_types(func)
             for r in self.returns:
                 if r is not None:
-                    stmts += self.evaluator.follow_statement(r)
+                    stmts += self._evaluator.follow_statement(r)
             return stmts
 
     @cache.memoize_default(default=())
@@ -666,7 +666,7 @@ class Execution(Executable):
                 if not len(commands):
                     continue
                 if commands[0] == '*':
-                    arrays = self.evaluator.follow_call_list(commands[1:])
+                    arrays = self._evaluator.follow_call_list(commands[1:])
                     # *args must be some sort of an array, otherwise -> ignore
 
                     for array in arrays:
@@ -678,7 +678,7 @@ class Execution(Executable):
                                 yield None, helpers.FakeStatement(field_stmt)
                 # **kwargs
                 elif commands[0] == '**':
-                    arrays = self.evaluator.follow_call_list(commands[1:])
+                    arrays = self._evaluator.follow_call_list(commands[1:])
                     for array in arrays:
                         if isinstance(array, Array):
                             for key_stmt, value_stmt in array.items():
@@ -831,7 +831,7 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
     methods which are important in this module.
     """
     def __init__(self, evaluator, array):
-        self.evaluator = evaluator
+        self._evaluator = evaluator
         self._array = array
 
     def get_index_types(self, index_arr=None):
@@ -887,7 +887,7 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
 
     def _follow_values(self, values):
         """ helper function for the index getters """
-        return list(itertools.chain.from_iterable(self.evaluator.follow_statement(v)
+        return list(itertools.chain.from_iterable(self._evaluator.follow_statement(v)
                                                   for v in values))
 
     def get_defined_names(self):
@@ -896,7 +896,7 @@ class Array(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
         It returns e.g. for a list: append, pop, ...
         """
         # `array.type` is a string with the type, e.g. 'list'.
-        scope = self.evaluator.find_name(builtin.Builtin.scope, self._array.type)[0]
+        scope = self._evaluator.find_name(builtin.Builtin.scope, self._array.type)[0]
         scope = Instance(scope)
         names = scope.get_defined_names()
         return [ArrayMethod(n) for n in names]

From 56457a9c8c8c4fa2eec3a89a48d095b54135e387 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 18:00:00 +0100
Subject: [PATCH 13/42] ImportPath has now also an _evaluator

---
 jedi/api.py                     |   4 +-
 jedi/api_classes.py             |   2 +-
 jedi/dynamic.py                 |   4 +-
 jedi/evaluate/__init__.py       | 183 ++++++++++++++++----------------
 jedi/evaluate/imports.py        |  13 +--
 jedi/evaluate/representation.py |   2 +-
 6 files changed, 104 insertions(+), 104 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index 9dd49bad..ba2c3a8e 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -413,7 +413,7 @@ class Script(object):
             for d in defs:
                 if isinstance(d.parent, pr.Import) \
                         and d.start_pos == (0, 0):
-                    i = imports.ImportPath(d.parent).follow(is_goto=True)
+                    i = imports.ImportPath(self._evaluator, d.parent).follow(is_goto=True)
                     definitions.remove(d)
                     definitions |= follow_inexistent_imports(i)
             return definitions
@@ -556,7 +556,7 @@ class Script(object):
         context = self._module.get_context()
         just_from = next(context) == 'from'
 
-        i = imports.ImportPath(user_stmt, is_like_search,
+        i = imports.ImportPath(self._evaluator, user_stmt, is_like_search,
                                kill_count=kill_count, direct_resolve=True,
                                is_just_from=just_from)
         return i, cur_name_part
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index af9a4737..95162da2 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -409,7 +409,7 @@ class Completion(BaseDefinition):
             if self._definition.isinstance(pr.Statement):
                 defs = evaluate.follow_statement(self._definition)
             elif self._definition.isinstance(pr.Import):
-                defs = imports.strip_imports([self._definition])
+                defs = imports.strip_imports(self._evaluator, [self._definition])
             else:
                 return [self]
 
diff --git a/jedi/dynamic.py b/jedi/dynamic.py
index 3d59c403..36a06b94 100644
--- a/jedi/dynamic.py
+++ b/jedi/dynamic.py
@@ -504,7 +504,7 @@ def usages(definitions, search_name, mods):
                             imps.append((count, name_part))
 
                 for used_count, name_part in imps:
-                    i = imports.ImportPath(stmt, kill_count=count - used_count,
+                    i = imports.ImportPath(_evaluator, stmt, kill_count=count - used_count,
                                            direct_resolve=True)
                     f = i.follow(is_goto=True)
                     if set(f) & set(definitions):
@@ -521,7 +521,7 @@ def usages_add_import_modules(definitions, search_name):
     new = set()
     for d in definitions:
         if isinstance(d.parent, pr.Import):
-            s = imports.ImportPath(d.parent, direct_resolve=True)
+            s = imports.ImportPath(_evaluator, d.parent, direct_resolve=True)
             with common.ignored(IndexError):
                 new.add(s.follow(is_goto=True)[0])
     return set(definitions) | new
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 32766952..39bfd332 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -115,97 +115,96 @@ def get_defined_names_for_position(scope, position=None, start_scope=None):
     return names_new
 
 
-def get_names_of_scope(scope, position=None, star_search=True,
-                       include_builtin=True):
-    """
-    Get all completions (names) possible for the current scope.
-    The star search option is only here to provide an optimization. Otherwise
-    the whole thing would probably start a little recursive madness.
-
-    This function is used to include names from outer scopes.  For example,
-    when the current scope is function:
-
-    >>> from jedi.parser import Parser
-    >>> parser = Parser('''
-    ... x = ['a', 'b', 'c']
-    ... def func():
-    ...     y = None
-    ... ''')
-    >>> scope = parser.module.subscopes[0]
-    >>> scope
-    <Function: func@3-4>
-
-    `get_names_of_scope` is a generator.  First it yields names from
-    most inner scope.
-
-    >>> pairs = list(get_names_of_scope(scope))
-    >>> pairs[0]
-    (<Function: func@3-4>, [<Name: y@4,4>])
-
-    Then it yield the names from one level outer scope.  For this
-    example, this is the most outer scope.
-
-    >>> pairs[1]
-    (<SubModule: None@1-4>, [<Name: x@2,0>, <Name: func@3,4>])
-
-    Finally, it yields names from builtin, if `include_builtin` is
-    true (default).
-
-    >>> pairs[2]                                        #doctest: +ELLIPSIS
-    (<Module: ...builtin...>, [<Name: ...>, ...])
-
-    :rtype: [(pr.Scope, [pr.Name])]
-    :return: Return an generator that yields a pair of scope and names.
-    """
-    in_func_scope = scope
-    non_flow = scope.get_parent_until(pr.Flow, reverse=True)
-    while scope:
-        if isinstance(scope, pr.SubModule) and scope.parent:
-            # we don't want submodules to report if we have modules.
-            scope = scope.parent
-            continue
-        # `pr.Class` is used, because the parent is never `Class`.
-        # Ignore the Flows, because the classes and functions care for that.
-        # InstanceElement of Class is ignored, if it is not the start scope.
-        if not (scope != non_flow and scope.isinstance(pr.Class)
-                or scope.isinstance(pr.Flow)
-                or scope.isinstance(er.Instance)
-                and non_flow.isinstance(er.Function)):
-            try:
-                if isinstance(scope, er.Instance):
-                    for g in scope.scope_generator():
-                        yield g
-                else:
-                    yield scope, get_defined_names_for_position(scope,
-                                                                position, in_func_scope)
-            except StopIteration:
-                reraise(common.MultiLevelStopIteration, sys.exc_info()[2])
-        if scope.isinstance(pr.ForFlow) and scope.is_list_comp:
-            # is a list comprehension
-            yield scope, scope.get_set_vars(is_internal_call=True)
-
-        scope = scope.parent
-        # This is used, because subscopes (Flow scopes) would distort the
-        # results.
-        if scope and scope.isinstance(er.Function, pr.Function, er.Execution):
-            in_func_scope = scope
-
-    # Add star imports.
-    if star_search:
-        for s in imports.remove_star_imports(non_flow.get_parent_until()):
-            for g in get_names_of_scope(s, star_search=False):
-                yield g
-
-        # Add builtins to the global scope.
-        if include_builtin:
-            builtin_scope = builtin.Builtin.scope
-            yield builtin_scope, builtin_scope.get_defined_names()
-
-
 class Evaluator(object):
     def __init__(self):
         self.cache = None
 
+    def get_names_of_scope(self, scope, position=None, star_search=True,
+                           include_builtin=True):
+        """
+        Get all completions (names) possible for the current scope.
+        The star search option is only here to provide an optimization. Otherwise
+        the whole thing would probably start a little recursive madness.
+
+        This function is used to include names from outer scopes.  For example,
+        when the current scope is function:
+
+        >>> from jedi.parser import Parser
+        >>> parser = Parser('''
+        ... x = ['a', 'b', 'c']
+        ... def func():
+        ...     y = None
+        ... ''')
+        >>> scope = parser.module.subscopes[0]
+        >>> scope
+        <Function: func@3-4>
+
+        `get_names_of_scope` is a generator.  First it yields names from
+        most inner scope.
+
+        >>> pairs = list(Evaluator().get_names_of_scope(scope))
+        >>> pairs[0]
+        (<Function: func@3-4>, [<Name: y@4,4>])
+
+        Then it yield the names from one level outer scope.  For this
+        example, this is the most outer scope.
+
+        >>> pairs[1]
+        (<SubModule: None@1-4>, [<Name: x@2,0>, <Name: func@3,4>])
+
+        Finally, it yields names from builtin, if `include_builtin` is
+        true (default).
+
+        >>> pairs[2]                                        #doctest: +ELLIPSIS
+        (<Module: ...builtin...>, [<Name: ...>, ...])
+
+        :rtype: [(pr.Scope, [pr.Name])]
+        :return: Return an generator that yields a pair of scope and names.
+        """
+        in_func_scope = scope
+        non_flow = scope.get_parent_until(pr.Flow, reverse=True)
+        while scope:
+            if isinstance(scope, pr.SubModule) and scope.parent:
+                # we don't want submodules to report if we have modules.
+                scope = scope.parent
+                continue
+            # `pr.Class` is used, because the parent is never `Class`.
+            # Ignore the Flows, because the classes and functions care for that.
+            # InstanceElement of Class is ignored, if it is not the start scope.
+            if not (scope != non_flow and scope.isinstance(pr.Class)
+                    or scope.isinstance(pr.Flow)
+                    or scope.isinstance(er.Instance)
+                    and non_flow.isinstance(er.Function)):
+                try:
+                    if isinstance(scope, er.Instance):
+                        for g in scope.scope_generator():
+                            yield g
+                    else:
+                        yield scope, get_defined_names_for_position(scope,
+                                                                    position, in_func_scope)
+                except StopIteration:
+                    reraise(common.MultiLevelStopIteration, sys.exc_info()[2])
+            if scope.isinstance(pr.ForFlow) and scope.is_list_comp:
+                # is a list comprehension
+                yield scope, scope.get_set_vars(is_internal_call=True)
+
+            scope = scope.parent
+            # This is used, because subscopes (Flow scopes) would distort the
+            # results.
+            if scope and scope.isinstance(er.Function, pr.Function, er.Execution):
+                in_func_scope = scope
+
+        # Add star imports.
+        if star_search:
+            for s in imports.remove_star_imports(self, non_flow.get_parent_until()):
+                for g in self.get_names_of_scope(s, star_search=False):
+                    yield g
+
+            # Add builtins to the global scope.
+            if include_builtin:
+                builtin_scope = builtin.Builtin.scope
+                yield builtin_scope, builtin_scope.get_defined_names()
+
     def find_name(self, scope, name_str, position=None, search_global=False,
                   is_goto=False, resolve_decorator=True):
         """
@@ -458,7 +457,7 @@ class Evaluator(object):
             return res_new
 
         if search_global:
-            scope_generator = get_names_of_scope(scope, position=position)
+            scope_generator = self.get_names_of_scope(scope, position=position)
         else:
             if isinstance(scope, er.Instance):
                 scope_generator = scope.scope_generator()
@@ -545,8 +544,8 @@ class Evaluator(object):
                 if isinstance(call, pr.Lambda):
                     result.append(er.Function(call))
                 # With things like params, these can also be functions...
-                elif isinstance(call, pr.Base) and call.isinstance(er.Function,
-                        er.Class, er.Instance, dynamic.ArrayInstance):
+                elif isinstance(call, pr.Base) and call.isinstance(
+                        er.Function, er.Class, er.Instance, dynamic.ArrayInstance):
                     result.append(call)
                 # The string tokens are just operations (+, -, etc.)
                 elif not isinstance(call, (str, unicode)):
@@ -596,7 +595,7 @@ class Evaluator(object):
                 scopes = self.find_name(builtin.Builtin.scope, current.type_as_string())
                 # Make instances of those number/string objects.
                 scopes = [er.Instance(s, (current.value,)) for s in scopes]
-            result = imports.strip_imports(scopes)
+            result = imports.strip_imports(self, scopes)
 
         return self.follow_paths(path, result, scope, position=position)
 
@@ -657,7 +656,7 @@ class Evaluator(object):
                 # This is the typical lookup while chaining things.
                 if filter_private_variable(scope, call_scope, current):
                     return []
-            result = imports.strip_imports(self.find_name(scope, current,
+            result = imports.strip_imports(self, self.find_name(scope, current,
                                            position=position))
         return self.follow_paths(path, set(result), call_scope, position=position)
 
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index 2c95e521..0221ec04 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -44,8 +44,9 @@ class ImportPath(pr.Base):
 
     GlobalNamespace = GlobalNamespace()
 
-    def __init__(self, import_stmt, is_like_search=False, kill_count=0,
+    def __init__(self, evaluator, import_stmt, is_like_search=False, kill_count=0,
                  direct_resolve=False, is_just_from=False):
+        self._evaluator = evaluator
         self.import_stmt = import_stmt
         self.is_like_search = is_like_search
         self.direct_resolve = direct_resolve
@@ -373,7 +374,7 @@ class ImportPath(pr.Base):
         return f.parser.module, rest
 
 
-def strip_imports(scopes):
+def strip_imports(evaluator, scopes):
     """
     Here we strip the imports - they don't get resolved necessarily.
     Really used anymore? Merge with remove_star_imports?
@@ -381,25 +382,25 @@ def strip_imports(scopes):
     result = []
     for s in scopes:
         if isinstance(s, pr.Import):
-            result += ImportPath(s).follow()
+            result += ImportPath(evaluator, s).follow()
         else:
             result.append(s)
     return result
 
 
 @cache.cache_star_import
-def remove_star_imports(scope, ignored_modules=()):
+def remove_star_imports(evaluator, scope, ignored_modules=()):
     """
     Check a module for star imports:
     >>> from module import *
 
     and follow these modules.
     """
-    modules = strip_imports(i for i in scope.get_imports() if i.star)
+    modules = strip_imports(evaluator, (i for i in scope.get_imports() if i.star))
     new = []
     for m in modules:
         if m not in ignored_modules:
-            new += remove_star_imports(m, modules)
+            new += remove_star_imports(evaluator, m, modules)
     modules += new
 
     # Filter duplicate modules.
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 11a3914b..9a4d3fb0 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -498,7 +498,7 @@ class Execution(Executable):
 
         debug.dbg('exec result: %s in %s' % (stmts, self))
 
-        return imports.strip_imports(stmts)
+        return imports.strip_imports(self._evaluator, stmts)
 
     def _get_function_returns(self, func, evaluate_generator):
         """ A normal Function execution """

From 066056fb2b899d93589b53429f17332241c66561 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 18:06:15 +0100
Subject: [PATCH 14/42] memoize_default should always take a first argument

---
 jedi/cache.py                   |  4 ++--
 jedi/docstrings.py              |  2 +-
 jedi/evaluate/representation.py | 18 +++++++++---------
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/jedi/cache.py b/jedi/cache.py
index 49ff3fda..98bfce77 100644
--- a/jedi/cache.py
+++ b/jedi/cache.py
@@ -81,7 +81,7 @@ def clear_caches(delete_all=False):
                     del tc[key]
 
 
-def memoize_default(default=None, cache=memoize_caches):
+def memoize_default(default, cache=memoize_caches):
     """ This is a typical memoization decorator, BUT there is one difference:
     To prevent recursion it sets defaults.
 
@@ -111,7 +111,7 @@ class CachedMetaClass(type):
     caches class initializations. I haven't found any other way, so I do it
     with meta classes.
     """
-    @memoize_default()
+    @memoize_default(None)
     def __call__(self, *args, **kwargs):
         return super(CachedMetaClass, self).__call__(*args, **kwargs)
 
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 3ccc506d..02e4579d 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -32,7 +32,7 @@ DOCSTRING_RETURN_PATTERNS = [
 REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
 
 
-@cache.memoize_default()
+@cache.memoize_default(None)
 def follow_param(param):
     func = param.parent_function
     # print func, param, param.parent_function
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 9a4d3fb0..f0d1790c 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -72,7 +72,7 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
         # (No var_args) used.
         self.is_generated = False
 
-    @cache.memoize_default()
+    @cache.memoize_default(None)
     def _get_method_execution(self, func):
         func = InstanceElement(self, func, True)
         return Execution(func, self.var_args)
@@ -205,7 +205,7 @@ class InstanceElement(use_metaclass(cache.CachedMetaClass, pr.Base)):
         self.is_class_var = is_class_var
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default(None)
     def parent(self):
         par = self.var.parent
         if isinstance(par, Class) and par == self.instance.base \
@@ -330,7 +330,7 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         self.base_func = func
         self.is_decorated = is_decorated
 
-    @cache.memoize_default()
+    @cache.memoize_default(None)
     def _decorated_func(self, instance=None):
         """
         Returns the function, that is to be executed in the end.
@@ -420,7 +420,7 @@ class Execution(Executable):
                 return [stmt]  # just some arbitrary object
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default(None)
     def _decorated(self):
         """Get the decorated version of the input"""
         base = self.base
@@ -736,7 +736,7 @@ class Execution(Executable):
             raise AttributeError('Tried to access %s: %s. Why?' % (name, self))
         return getattr(self._decorated, name)
 
-    @cache.memoize_default()
+    @cache.memoize_default(None)
     @common.rethrow_uncaught
     def _scope_copy(self, scope):
         """ Copies a scope (e.g. if) in an execution """
@@ -752,22 +752,22 @@ class Execution(Executable):
             return copied
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default([])
     def returns(self):
         return self._copy_properties('returns')
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default([])
     def asserts(self):
         return self._copy_properties('asserts')
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default([])
     def statements(self):
         return self._copy_properties('statements')
 
     @property
-    @cache.memoize_default()
+    @cache.memoize_default([])
     def subscopes(self):
         return self._copy_properties('subscopes')
 

From ab2c6bf45d0e2422161c4b0809d6d714c0ccbec3 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 18:46:40 +0100
Subject: [PATCH 15/42] integrate memoize caches into evaluator

---
 jedi/cache.py                   | 48 +--------------------------------
 jedi/docstrings.py              |  4 +--
 jedi/dynamic.py                 |  5 ++--
 jedi/evaluate/__init__.py       |  6 ++---
 jedi/evaluate/cache.py          | 48 +++++++++++++++++++++++++++++++++
 jedi/evaluate/imports.py        |  2 +-
 jedi/evaluate/representation.py | 48 ++++++++++++++++-----------------
 jedi/modules.py                 |  2 +-
 8 files changed, 83 insertions(+), 80 deletions(-)
 create mode 100644 jedi/evaluate/cache.py

diff --git a/jedi/cache.py b/jedi/cache.py
index 98bfce77..918af40d 100644
--- a/jedi/cache.py
+++ b/jedi/cache.py
@@ -5,9 +5,6 @@ available:
 
 - module caching (`load_module` and `save_module`), which uses pickle and is
   really important to assure low load times of modules like ``numpy``.
-- the popular ``memoize_default`` works like a typical memoize and returns the
-  default otherwise.
-- ``CachedMetaClass`` uses ``memoize_default`` to do the same with classes.
 - ``time_cache`` can be used to cache something for just a limited time span,
   which can be useful if there's user interaction and the user cannot react
   faster than a certain time.
@@ -34,9 +31,6 @@ from jedi import settings
 from jedi import common
 from jedi import debug
 
-# memoize caches will be deleted after every action
-memoize_caches = []
-
 time_caches = []
 
 star_import_cache = {}
@@ -60,12 +54,7 @@ def clear_caches(delete_all=False):
     :param delete_all: Deletes also the cache that is normally not deleted,
         like parser cache, which is important for faster parsing.
     """
-    global memoize_caches, time_caches
-
-    # memorize_caches must never be deleted, because the dicts will get lost in
-    # the wrappers.
-    for m in memoize_caches:
-        m.clear()
+    global time_caches
 
     if delete_all:
         time_caches = []
@@ -81,41 +70,6 @@ def clear_caches(delete_all=False):
                     del tc[key]
 
 
-def memoize_default(default, cache=memoize_caches):
-    """ This is a typical memoization decorator, BUT there is one difference:
-    To prevent recursion it sets defaults.
-
-    Preventing recursion is in this case the much bigger use than speed. I
-    don't think, that there is a big speed difference, but there are many cases
-    where recursion could happen (think about a = b; b = a).
-    """
-    def func(function):
-        memo = {}
-        cache.append(memo)
-
-        def wrapper(*args, **kwargs):
-            key = (args, frozenset(kwargs.items()))
-            if key in memo:
-                return memo[key]
-            else:
-                memo[key] = default
-                rv = function(*args, **kwargs)
-                memo[key] = rv
-                return rv
-        return wrapper
-    return func
-
-
-class CachedMetaClass(type):
-    """ This is basically almost the same than the decorator above, it just
-    caches class initializations. I haven't found any other way, so I do it
-    with meta classes.
-    """
-    @memoize_default(None)
-    def __call__(self, *args, **kwargs):
-        return super(CachedMetaClass, self).__call__(*args, **kwargs)
-
-
 def time_cache(time_add_setting):
     """ This decorator works as follows: Call it with a setting and after that
     use the function with a callable that returns the key.
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 02e4579d..477f999d 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -16,7 +16,7 @@ annotations.
 
 import re
 
-from jedi import cache
+from jedi.evaluate.cache import memoize_default
 from jedi.parser import Parser
 
 DOCSTRING_PARAM_PATTERNS = [
@@ -32,7 +32,7 @@ DOCSTRING_RETURN_PATTERNS = [
 REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
 
 
-@cache.memoize_default(None)
+@memoize_default(None)
 def follow_param(param):
     func = param.parent_function
     # print func, param, param.parent_function
diff --git a/jedi/dynamic.py b/jedi/dynamic.py
index 36a06b94..8bbda015 100644
--- a/jedi/dynamic.py
+++ b/jedi/dynamic.py
@@ -63,6 +63,7 @@ from jedi import common
 from jedi import debug
 from jedi.parser import fast as fast_parser
 from jedi.evaluate import imports
+from jedi.evaluate.cache import memoize_default
 
 # This is something like the sys.path, but only for searching params. It means
 # that this is the order in which Jedi searches params.
@@ -140,7 +141,7 @@ class ParamListener(object):
         self.param_possibilities.append(params)
 
 
-@cache.memoize_default([])
+@memoize_default([])
 def search_params(param):
     """
     This is a dynamic search for params. If you try to complete a type:
@@ -299,7 +300,7 @@ def _scan_statement(stmt, search_name, assignment_details=False):
     return result
 
 
-@cache.memoize_default([])
+@memoize_default([])
 def _check_array_additions(compare_array, module, is_list):
     """
     Checks if a `pr.Array` has "add" statements:
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 39bfd332..53f90904 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -75,13 +75,13 @@ import itertools
 
 from jedi._compatibility import next, hasattr, is_py3k, unicode, reraise, u
 from jedi import common
-from jedi import cache
 from jedi.parser import representation as pr
 from jedi import debug
 from jedi.evaluate import representation as er
 from jedi.evaluate import builtin
 from jedi.evaluate import imports
 from jedi.evaluate import recursion
+from jedi.evaluate.cache import memoize_default
 from jedi import docstrings
 from jedi import dynamic
 
@@ -117,7 +117,7 @@ def get_defined_names_for_position(scope, position=None, start_scope=None):
 
 class Evaluator(object):
     def __init__(self):
-        self.cache = None
+        self.memoize_cache = {}
 
     def get_names_of_scope(self, scope, position=None, star_search=True,
                            include_builtin=True):
@@ -474,7 +474,7 @@ class Evaluator(object):
             return filter_name(scope_generator)
         return descriptor_check(remove_statements(filter_name(scope_generator)))
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=(), cache_is_in_self=True)
     @recursion.RecursionDecorator
     def follow_statement(self, stmt, seek_name=None):
         """
diff --git a/jedi/evaluate/cache.py b/jedi/evaluate/cache.py
new file mode 100644
index 00000000..3ef7ebc7
--- /dev/null
+++ b/jedi/evaluate/cache.py
@@ -0,0 +1,48 @@
+"""
+- the popular ``memoize_default`` works like a typical memoize and returns the
+  default otherwise.
+- ``CachedMetaClass`` uses ``memoize_default`` to do the same with classes.
+"""
+
+
+def memoize_default(default, cache_is_in_self=False):
+    """ This is a typical memoization decorator, BUT there is one difference:
+    To prevent recursion it sets defaults.
+
+    Preventing recursion is in this case the much bigger use than speed. I
+    don't think, that there is a big speed difference, but there are many cases
+    where recursion could happen (think about a = b; b = a).
+    """
+    def func(function):
+        def wrapper(obj, *args, **kwargs):
+            if cache_is_in_self:
+                cache = obj.memoize_cache
+            else:
+                cache = obj._evaluator.memoize_cache
+
+            try:
+                memo = cache[function]
+            except KeyError:
+                memo = {}
+                cache[function] = function
+
+            key = (args, frozenset(kwargs.items()))
+            if key in memo:
+                return memo[key]
+            else:
+                memo[key] = default
+                rv = function(obj, *args, **kwargs)
+                memo[key] = rv
+                return rv
+        return wrapper
+    return func
+
+
+class CachedMetaClass(type):
+    """ This is basically almost the same than the decorator above, it just
+    caches class initializations. I haven't found any other way, so I do it
+    with meta classes.
+    """
+    @memoize_default(None)
+    def __call__(self, *args, **kwargs):
+        return super(CachedMetaClass, self).__call__(*args, **kwargs)
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index 0221ec04..2d423848 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -200,7 +200,7 @@ class ImportPath(pr.Base):
                 return []
 
             scopes = [scope]
-            scopes += remove_star_imports(scope)
+            scopes += remove_star_imports(self._evaluator, scope)
 
             # follow the rest of the import (not FS -> classes, functions)
             if len(rest) > 1 or rest and self.is_like_search:
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index f0d1790c..4d539a75 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -16,16 +16,16 @@ import itertools
 
 from jedi._compatibility import use_metaclass, next, hasattr, unicode
 from jedi.parser import representation as pr
-from jedi import cache
 from jedi import helpers
 from jedi import debug
 from jedi import common
 from jedi.evaluate import imports
 from jedi.evaluate import builtin
 from jedi.evaluate import recursion
+from jedi.evaluate.cache import memoize_default, CachedMetaClass
+from jedi.evaluate.interfaces import Iterable
 from jedi import docstrings
 from jedi import dynamic
-from jedi.evaluate.interfaces import Iterable
 
 
 class Executable(pr.IsScope):
@@ -53,7 +53,7 @@ class Executable(pr.IsScope):
         return self.base
 
 
-class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
+class Instance(use_metaclass(CachedMetaClass, Executable)):
     """
     This class is used to evaluate instances.
     """
@@ -72,7 +72,7 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
         # (No var_args) used.
         self.is_generated = False
 
-    @cache.memoize_default(None)
+    @memoize_default(None)
     def _get_method_execution(self, func):
         func = InstanceElement(self, func, True)
         return Execution(func, self.var_args)
@@ -87,7 +87,7 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
         except IndexError:
             return None
 
-    @cache.memoize_default([])
+    @memoize_default([])
     def _get_self_attributes(self):
         def add_self_dot_name(name):
             """
@@ -144,7 +144,7 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
         args = [obj, obj.base] if isinstance(obj, Instance) else [None, obj]
         return self.execute_subscope_by_name('__get__', args)
 
-    @cache.memoize_default([])
+    @memoize_default([])
     def get_defined_names(self):
         """
         Get the instance vars of a class. This includes the vars of all
@@ -190,7 +190,7 @@ class Instance(use_metaclass(cache.CachedMetaClass, Executable)):
             (type(self).__name__, self.base, len(self.var_args or []))
 
 
-class InstanceElement(use_metaclass(cache.CachedMetaClass, pr.Base)):
+class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
     """
     InstanceElement is a wrapper for any object, that is used as an instance
     variable (e.g. self.variable or class methods).
@@ -205,7 +205,7 @@ class InstanceElement(use_metaclass(cache.CachedMetaClass, pr.Base)):
         self.is_class_var = is_class_var
 
     @property
-    @cache.memoize_default(None)
+    @memoize_default(None)
     def parent(self):
         par = self.var.parent
         if isinstance(par, Class) and par == self.instance.base \
@@ -246,7 +246,7 @@ class InstanceElement(use_metaclass(cache.CachedMetaClass, pr.Base)):
         return "<%s of %s>" % (type(self).__name__, self.var)
 
 
-class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
+class Class(use_metaclass(CachedMetaClass, pr.IsScope)):
     """
     This class is not only important to extend `pr.Class`, it is also a
     important for descriptors (if the descriptor methods are evaluated or not).
@@ -255,7 +255,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         self._evaluator = evaluator
         self.base = base
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=())
     def get_super_classes(self):
         supers = []
         # TODO care for mro stuff (multiple super classes).
@@ -271,7 +271,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
             supers += self._evaluator.find_name(builtin.Builtin.scope, 'object')
         return supers
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=())
     def instance_names(self):
         def in_iterable(name, iterable):
             """ checks if the name is in the variable 'iterable'. """
@@ -293,7 +293,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         result += super_result
         return result
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=())
     def get_defined_names(self):
         result = self.instance_names()
         type_cls = self._evaluator.find_name(builtin.Builtin.scope, 'type')[0]
@@ -320,7 +320,7 @@ class Class(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         return "<e%s of %s>" % (type(self).__name__, self.base)
 
 
-class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
+class Function(use_metaclass(CachedMetaClass, pr.IsScope)):
     """
     Needed because of decorators. Decorators are evaluated here.
     """
@@ -330,7 +330,7 @@ class Function(use_metaclass(cache.CachedMetaClass, pr.IsScope)):
         self.base_func = func
         self.is_decorated = is_decorated
 
-    @cache.memoize_default(None)
+    @memoize_default(None)
     def _decorated_func(self, instance=None):
         """
         Returns the function, that is to be executed in the end.
@@ -420,7 +420,7 @@ class Execution(Executable):
                 return [stmt]  # just some arbitrary object
 
     @property
-    @cache.memoize_default(None)
+    @memoize_default(None)
     def _decorated(self):
         """Get the decorated version of the input"""
         base = self.base
@@ -428,7 +428,7 @@ class Execution(Executable):
             base = base.get_decorated_func()
         return base
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=())
     @recursion.ExecutionRecursionDecorator
     def get_return_types(self, evaluate_generator=False):
         """ Get the return types of a function. """
@@ -514,7 +514,7 @@ class Execution(Executable):
                     stmts += self._evaluator.follow_statement(r)
             return stmts
 
-    @cache.memoize_default(default=())
+    @memoize_default(default=())
     def _get_params(self):
         """
         This returns the params for an Execution/Instance and is injected as a
@@ -736,7 +736,7 @@ class Execution(Executable):
             raise AttributeError('Tried to access %s: %s. Why?' % (name, self))
         return getattr(self._decorated, name)
 
-    @cache.memoize_default(None)
+    @memoize_default(None)
     @common.rethrow_uncaught
     def _scope_copy(self, scope):
         """ Copies a scope (e.g. if) in an execution """
@@ -752,22 +752,22 @@ class Execution(Executable):
             return copied
 
     @property
-    @cache.memoize_default([])
+    @memoize_default([])
     def returns(self):
         return self._copy_properties('returns')
 
     @property
-    @cache.memoize_default([])
+    @memoize_default([])
     def asserts(self):
         return self._copy_properties('asserts')
 
     @property
-    @cache.memoize_default([])
+    @memoize_default([])
     def statements(self):
         return self._copy_properties('statements')
 
     @property
-    @cache.memoize_default([])
+    @memoize_default([])
     def subscopes(self):
         return self._copy_properties('subscopes')
 
@@ -779,7 +779,7 @@ class Execution(Executable):
             (type(self).__name__, self._decorated)
 
 
-class Generator(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
+class Generator(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
     """ Cares for `yield` statements. """
     def __init__(self, func, var_args):
         super(Generator, self).__init__()
@@ -825,7 +825,7 @@ class Generator(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
         return "<%s of %s>" % (type(self).__name__, self.func)
 
 
-class Array(use_metaclass(cache.CachedMetaClass, pr.Base, Iterable)):
+class Array(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
     """
     Used as a mirror to pr.Array, if needed. It defines some getter
     methods which are important in this module.
diff --git a/jedi/modules.py b/jedi/modules.py
index c603f772..51e0d4fe 100644
--- a/jedi/modules.py
+++ b/jedi/modules.py
@@ -291,7 +291,7 @@ def get_sys_path():
     return [p for p in sys.path if p != ""]
 
 
-@cache.memoize_default([])
+#@cache.memoize_default([]) TODO add some sort of cache again.
 def sys_path_with_modifications(module):
     def execute_code(code):
         c = "import os; from os.path import *; result=%s"

From 118ed2e0a3fe2d3e02141f23208ab896cbe6cc8f Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 18:49:03 +0100
Subject: [PATCH 16/42] RecursionNode should be public

---
 jedi/evaluate/recursion.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/jedi/evaluate/recursion.py b/jedi/evaluate/recursion.py
index baa1bc9d..e80f2f9d 100644
--- a/jedi/evaluate/recursion.py
+++ b/jedi/evaluate/recursion.py
@@ -33,7 +33,7 @@ class RecursionDecorator(object):
         return result
 
     def push_stmt(self, stmt):
-        self.current = RecursionNode(stmt, self.current)
+        self.current = _RecursionNode(stmt, self.current)
         check = self._check_recursion()
         if check:  # TODO remove False!!!!
             debug.warning('catched stmt recursion: %s against %s @%s'
@@ -70,7 +70,7 @@ class RecursionDecorator(object):
         return result
 
 
-class RecursionNode(object):
+class _RecursionNode(object):
     """ A node of the RecursionDecorator. """
     def __init__(self, stmt, parent):
         self.script = stmt.get_parent_until()

From 85a12e8866107182e306b688c48a8032f77cfcd5 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 19:14:14 +0100
Subject: [PATCH 17/42] RecursionDecorator now also works with Evaluator caches

---
 jedi/api_classes.py        |  2 +-
 jedi/evaluate/__init__.py  |  5 +++--
 jedi/evaluate/imports.py   |  4 ++--
 jedi/evaluate/recursion.py | 34 +++++++++++++++++-----------------
 4 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index 95162da2..d927cb23 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -24,7 +24,7 @@ def _clear_caches():
     """
     cache.clear_caches()
     dynamic.search_param_cache.clear()
-    #recursion.ExecutionRecursionDecorator.reset()
+    recursion.ExecutionRecursionDecorator.reset()
 
     evaluate.follow_statement.reset()
 
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 53f90904..5cfd5a38 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -117,7 +117,8 @@ def get_defined_names_for_position(scope, position=None, start_scope=None):
 
 class Evaluator(object):
     def __init__(self):
-        self.memoize_cache = {}
+        self.memoize_cache = {}  # for memoize decorators
+        self.recursion_detector = recursion.RecursionDetector()
 
     def get_names_of_scope(self, scope, position=None, star_search=True,
                            include_builtin=True):
@@ -475,7 +476,7 @@ class Evaluator(object):
         return descriptor_check(remove_statements(filter_name(scope_generator)))
 
     @memoize_default(default=(), cache_is_in_self=True)
-    @recursion.RecursionDecorator
+    @recursion.recursion_decorator
     def follow_statement(self, stmt, seek_name=None):
         """
         The starting point of the completion. A statement always owns a call list,
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index 2d423848..c6a5d913 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -187,7 +187,7 @@ class ImportPath(pr.Base):
         """
         Returns the imported modules.
         """
-        if self._evaluator.follow_statement.push_stmt(self.import_stmt):
+        if self._evaluator.recursion_detector.push_stmt(self.import_stmt):
             # check recursion
             return []
 
@@ -229,7 +229,7 @@ class ImportPath(pr.Base):
             scopes = [ImportPath.GlobalNamespace]
         debug.dbg('after import', scopes)
 
-        self._evaluator.follow_statement.pop_stmt()
+        self._evaluator.recursion_detector.pop_stmt()
         return scopes
 
     def _is_relative_import(self):
diff --git a/jedi/evaluate/recursion.py b/jedi/evaluate/recursion.py
index e80f2f9d..566fd23c 100644
--- a/jedi/evaluate/recursion.py
+++ b/jedi/evaluate/recursion.py
@@ -14,23 +14,27 @@ from jedi.evaluate import builtin
 from jedi.evaluate import interfaces
 
 
-class RecursionDecorator(object):
+def recursion_decorator(func):
+    def run(evaluator, stmt, *args, **kwargs):
+        rec_detect = evaluator.recursion_detector
+        # print stmt, len(self.node_statements())
+        if rec_detect.push_stmt(stmt):
+            return []
+        else:
+            result = func(evaluator, stmt, *args, **kwargs)
+            rec_detect.pop_stmt()
+        return result
+    return run
+
+
+class RecursionDetector(object):
     """
     A decorator to detect recursions in statements. In a recursion a statement
     at the same place, in the same module may not be executed two times.
     """
-    def __init__(self, func):
-        self.func = func
-        self.reset()
-
-    def __call__(self, evaluator, stmt, *args, **kwargs):
-        # print stmt, len(self.node_statements())
-        if self.push_stmt(stmt):
-            return []
-        else:
-            result = self.func(evaluator, stmt, *args, **kwargs)
-            self.pop_stmt()
-        return result
+    def __init__(self):
+        self.top = None
+        self.current = None
 
     def push_stmt(self, stmt):
         self.current = _RecursionNode(stmt, self.current)
@@ -57,10 +61,6 @@ class RecursionDecorator(object):
             if not test:
                 return False
 
-    def reset(self):
-        self.top = None
-        self.current = None
-
     def node_statements(self):
         result = []
         n = self.current

From 39ed0d0f8ac1378f617e81bf1bb393b9c2e4dab5 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 19:47:52 +0100
Subject: [PATCH 18/42] most evaluate representation classes probably receive
 the evaluator instance now

---
 jedi/evaluate/__init__.py       | 16 +++++-----
 jedi/evaluate/cache.py          | 15 +++++----
 jedi/evaluate/representation.py | 54 ++++++++++++++++++---------------
 3 files changed, 47 insertions(+), 38 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 5cfd5a38..f9af24d7 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -255,10 +255,12 @@ class Evaluator(object):
                                 r = func.var.params[r.position_nr]
 
                             # add docstring knowledge
-                            doc_params = docstrings.follow_param(r)
+                            """
+                            doc_params = docstrings.follow_param(r) TODO ENABLE
                             if doc_params:
                                 res_new += doc_params
                                 continue
+                                """
 
                             if not r.is_generated:
                                 res_new += dynamic.search_params(r)
@@ -267,7 +269,7 @@ class Evaluator(object):
                                     if c in ('*', '**'):
                                         t = 'tuple' if c == '*' else 'dict'
                                         res_new = [er.Instance(
-                                            self.find_name(builtin.Builtin.scope, t)[0])
+                                            self, self.find_name(builtin.Builtin.scope, t)[0])
                                         ]
                                 if not r.assignment_details:
                                     # this means that there are no default params,
@@ -284,7 +286,7 @@ class Evaluator(object):
 
                     if check_instance is not None:
                         # class renames
-                        add = [er.InstanceElement(check_instance, a, True)
+                        add = [er.InstanceElement(self, check_instance, a, True)
                                if isinstance(a, (er.Function, pr.Function))
                                else a for a in add]
                     res_new += add
@@ -346,7 +348,7 @@ class Evaluator(object):
                     if isinstance(scope, er.InstanceElement):
                         inst = scope.instance
                     else:
-                        inst = er.Instance(er.Class(until()))
+                        inst = er.Instance(self, er.Class(self, until()))
                         inst.is_generated = True
                     result.append(inst)
                 elif par.isinstance(pr.Statement):
@@ -543,7 +545,7 @@ class Evaluator(object):
                 result += self.follow_statement(call.stmt)
             else:
                 if isinstance(call, pr.Lambda):
-                    result.append(er.Function(call))
+                    result.append(er.Function(self, call))
                 # With things like params, these can also be functions...
                 elif isinstance(call, pr.Base) and call.isinstance(
                         er.Function, er.Class, er.Instance, dynamic.ArrayInstance):
@@ -595,7 +597,7 @@ class Evaluator(object):
                 # for pr.Literal
                 scopes = self.find_name(builtin.Builtin.scope, current.type_as_string())
                 # Make instances of those number/string objects.
-                scopes = [er.Instance(s, (current.value,)) for s in scopes]
+                scopes = [er.Instance(self, s, (current.value,)) for s in scopes]
             result = imports.strip_imports(self, scopes)
 
         return self.follow_paths(path, result, scope, position=position)
@@ -662,7 +664,7 @@ class Evaluator(object):
         return self.follow_paths(path, set(result), call_scope, position=position)
 
     def execute(self, scope, params, evaluate_generator=False):
-        return er.Execution(scope, params).get_return_types(evaluate_generator)
+        return er.Execution(self, scope, params).get_return_types(evaluate_generator)
 
     def goto(self, stmt, call_path=None):
         if call_path is None:
diff --git a/jedi/evaluate/cache.py b/jedi/evaluate/cache.py
index 3ef7ebc7..44526373 100644
--- a/jedi/evaluate/cache.py
+++ b/jedi/evaluate/cache.py
@@ -5,7 +5,7 @@
 """
 
 
-def memoize_default(default, cache_is_in_self=False):
+def memoize_default(default, cache_is_in_self=False, first_arg_is_evaluator=False):
     """ This is a typical memoization decorator, BUT there is one difference:
     To prevent recursion it sets defaults.
 
@@ -17,6 +17,8 @@ def memoize_default(default, cache_is_in_self=False):
         def wrapper(obj, *args, **kwargs):
             if cache_is_in_self:
                 cache = obj.memoize_cache
+            elif first_arg_is_evaluator:  # needed for meta classes
+                cache = args[0].memoize_cache
             else:
                 cache = obj._evaluator.memoize_cache
 
@@ -24,7 +26,7 @@ def memoize_default(default, cache_is_in_self=False):
                 memo = cache[function]
             except KeyError:
                 memo = {}
-                cache[function] = function
+                cache[function] = memo
 
             key = (args, frozenset(kwargs.items()))
             if key in memo:
@@ -39,10 +41,11 @@ def memoize_default(default, cache_is_in_self=False):
 
 
 class CachedMetaClass(type):
-    """ This is basically almost the same than the decorator above, it just
-    caches class initializations. I haven't found any other way, so I do it
-    with meta classes.
     """
-    @memoize_default(None)
+    This is basically almost the same than the decorator above, it just caches
+    class initializations. I haven't found any other way, so I'm doing it with
+    meta classes.
+    """
+    @memoize_default(None, first_arg_is_evaluator=True)
     def __call__(self, *args, **kwargs):
         return super(CachedMetaClass, self).__call__(*args, **kwargs)
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 4d539a75..dee8a273 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -34,7 +34,7 @@ class Executable(pr.IsScope):
     :param var_args: The param input array, consist of `pr.Array` or list.
     """
     def __init__(self, evaluator, base, var_args=()):
-        self.evaluator = evaluator
+        self._evaluator = evaluator
         self.base = base
         self.var_args = var_args
 
@@ -74,8 +74,8 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
 
     @memoize_default(None)
     def _get_method_execution(self, func):
-        func = InstanceElement(self, func, True)
-        return Execution(func, self.var_args)
+        func = InstanceElement(self._evaluator, self, func, True)
+        return Execution(self._evaluator, func, self.var_args)
 
     def _get_func_self_name(self, func):
         """
@@ -96,7 +96,7 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
             """
             n = copy.copy(name)
             n.names = n.names[1:]
-            names.append(InstanceElement(self, n))
+            names.append(InstanceElement(self._evaluator, self, n))
 
         names = []
         # This loop adds the names of the self object, copies them and removes
@@ -125,17 +125,17 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
                     add_self_dot_name(n)
 
         for s in self.base.get_super_classes():
-            names += Instance(s)._get_self_attributes()
+            names += Instance(self._evaluator, s)._get_self_attributes()
 
         return names
 
     def get_subscope_by_name(self, name):
         sub = self.base.get_subscope_by_name(name)
-        return InstanceElement(self, sub, True)
+        return InstanceElement(self._evaluator, self, sub, True)
 
     def execute_subscope_by_name(self, name, args=()):
         method = self.get_subscope_by_name(name)
-        return Execution(method, args).get_return_types()
+        return Execution(self._evaluator, method, args).get_return_types()
 
     def get_descriptor_return(self, obj):
         """ Throws a KeyError if there's no method. """
@@ -154,7 +154,7 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
 
         class_names = self.base.instance_names()
         for var in class_names:
-            names.append(InstanceElement(self, var, True))
+            names.append(InstanceElement(self._evaluator, self, var, True))
         return names
 
     def scope_generator(self):
@@ -167,7 +167,7 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
         names = []
         class_names = self.base.instance_names()
         for var in class_names:
-            names.append(InstanceElement(self, var, True))
+            names.append(InstanceElement(self._evaluator, self, var, True))
         yield self, names
 
     def get_index_types(self, index=None):
@@ -195,9 +195,9 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
     InstanceElement is a wrapper for any object, that is used as an instance
     variable (e.g. self.variable or class methods).
     """
-    def __init__(self, instance, var, is_class_var=False):
+    def __init__(self, evaluator, instance, var, is_class_var=False):
         if isinstance(var, pr.Function):
-            var = Function(var)
+            var = Function(evaluator, var)
         elif isinstance(var, pr.Class):
             var = Class(var)
         self.instance = instance
@@ -213,7 +213,7 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
                 and par == self.instance.base.base:
             par = self.instance
         elif not isinstance(par, pr.Module):
-            par = InstanceElement(self.instance, par, self.is_class_var)
+            par = InstanceElement(self.instance._evaluator, self.instance, par, self.is_class_var)
         return par
 
     def get_parent_until(self, *args, **kwargs):
@@ -228,13 +228,13 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
 
     def get_commands(self):
         # Copy and modify the array.
-        return [InstanceElement(self.instance, command, self.is_class_var)
+        return [InstanceElement(self.instance._evaluator, self.instance, command, self.is_class_var)
                 if not isinstance(command, unicode) else command
                 for command in self.var.get_commands()]
 
     def __iter__(self):
         for el in self.var.__iter__():
-            yield InstanceElement(self.instance, el, self.is_class_var)
+            yield InstanceElement(self.instance._evaluator, self.instance, el, self.is_class_var)
 
     def __getattr__(self, name):
         return getattr(self.var, name)
@@ -352,12 +352,12 @@ class Function(use_metaclass(CachedMetaClass, pr.IsScope)):
                     debug.warning('multiple decorators found', self.base_func,
                                   dec_results)
                 # Create param array.
-                old_func = Function(f, is_decorated=True)
+                old_func = Function(self._evaluator, f, is_decorated=True)
                 if instance is not None and decorator.isinstance(Function):
-                    old_func = InstanceElement(instance, old_func)
+                    old_func = InstanceElement(self._evaluator, instance, old_func)
                     instance = None
 
-                wrappers = Execution(decorator, (old_func,)).get_return_types()
+                wrappers = Execution(self._evaluator, decorator, (old_func,)).get_return_types()
                 if not len(wrappers):
                     debug.warning('no wrappers found', self.base_func)
                     return None
@@ -369,7 +369,7 @@ class Function(use_metaclass(CachedMetaClass, pr.IsScope)):
 
                 debug.dbg('decorator end', f)
         if f != self.base_func and isinstance(f, pr.Function):
-            f = Function(f)
+            f = Function(self._evaluator, f)
         return f
 
     def get_decorated_func(self, instance=None):
@@ -380,7 +380,7 @@ class Function(use_metaclass(CachedMetaClass, pr.IsScope)):
             # If the decorator func is not found, just ignore the decorator
             # function, because sometimes decorators are just really
             # complicated.
-            return Function(self.base_func, True)
+            return Function(self._evaluator, self.base_func, True)
         return decorated_func
 
     def get_magic_method_names(self):
@@ -473,12 +473,12 @@ class Execution(Executable):
                         cls = Class(cls)
                         su = cls.get_super_classes()
                         if su:
-                            return [Instance(su[0])]
+                            return [Instance(self._evaluator, su[0])]
                 return []
 
         if base.isinstance(Class):
             # There maybe executions of executions.
-            return [Instance(base, self.var_args)]
+            return [Instance(self._evaluator, base, self.var_args)]
         elif isinstance(base, Generator):
             return base.iter_content()
         else:
@@ -508,7 +508,10 @@ class Execution(Executable):
         if func.is_generator and not evaluate_generator:
             return [Generator(func, self.var_args)]
         else:
+            """
             stmts = docstrings.find_return_types(func)
+            """
+            stmts=[]
             for r in self.returns:
                 if r is not None:
                     stmts += self._evaluator.follow_statement(r)
@@ -727,7 +730,7 @@ class Execution(Executable):
                 copied = helpers.fast_parent_copy(element)
                 copied.parent = self._scope_copy(copied.parent)
                 if isinstance(copied, pr.Function):
-                    copied = Function(copied)
+                    copied = Function(self._evaluator, copied)
             objects.append(copied)
         return objects
 
@@ -781,7 +784,8 @@ class Execution(Executable):
 
 class Generator(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
     """ Cares for `yield` statements. """
-    def __init__(self, func, var_args):
+    def __init__(self, evaluator, func, var_args):
+        # Need evaluator for `CachedMetaClass`.
         super(Generator, self).__init__()
         self.func = func
         self.var_args = var_args
@@ -807,7 +811,7 @@ class Generator(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
 
     def iter_content(self):
         """ returns the content of __iter__ """
-        return Execution(self.func, self.var_args).get_return_types(True)
+        return Execution(self._evaluator, self.func, self.var_args).get_return_types(True)
 
     def get_index_types(self, index=None):
         debug.warning('Tried to get array access on a generator', self)
@@ -897,7 +901,7 @@ class Array(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
         """
         # `array.type` is a string with the type, e.g. 'list'.
         scope = self._evaluator.find_name(builtin.Builtin.scope, self._array.type)[0]
-        scope = Instance(scope)
+        scope = Instance(self._evaluator, scope)
         names = scope.get_defined_names()
         return [ArrayMethod(n) for n in names]
 

From 9e52d51a6ba31df5668bad2872a04cde676df243 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 19:50:53 +0100
Subject: [PATCH 19/42] use filter_private_variable correctly in api

---
 jedi/api.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index ba2c3a8e..8b4ebec5 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -25,7 +25,7 @@ from jedi import cache
 from jedi import modules
 from jedi import interpret
 from jedi._compatibility import next, unicode, builtins
-from jedi.evaluate import Evaluator
+from jedi.evaluate import Evaluator, filter_private_variable
 from jedi.evaluate import representation as er
 from jedi import keywords
 from jedi.evaluate import builtin
@@ -160,7 +160,7 @@ class Script(object):
             if settings.case_insensitive_completion \
                     and n.lower().startswith(like.lower()) \
                     or n.startswith(like):
-                if not evaluate.filter_private_variable(s,
+                if not filter_private_variable(s,
                             user_stmt or self._parser.user_scope, n):
                     new = api_classes.Completion(c, needs_dot, len(like), s)
                     k = (new.name, new.complete)  # key
@@ -181,7 +181,7 @@ class Script(object):
             scopes = list(self._prepare_goto(path, True))
         except NotFoundError:
             scopes = []
-            scope_generator = evaluate.get_names_of_scope(
+            scope_generator = self._evaluator.get_names_of_scope(
                 self._parser.user_scope, self._pos)
             completions = []
             for scope, name_list in scope_generator:

From 83266581344d55a2240162e14fd5d1800a230a4b Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 19:55:11 +0100
Subject: [PATCH 20/42] more improvements, so that almost all import tests pass
 again

---
 jedi/evaluate/__init__.py       | 2 +-
 jedi/evaluate/imports.py        | 2 +-
 jedi/evaluate/representation.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index f9af24d7..86432196 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -587,7 +587,7 @@ class Evaluator(object):
         current = next(path)
 
         if isinstance(current, pr.Array):
-            result = [er.Array(current)]
+            result = [er.Array(self, current)]
         else:
             if isinstance(current, pr.NamePart):
                 # This is the first global lookup.
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index c6a5d913..aa6637fa 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -196,7 +196,7 @@ class ImportPath(pr.Base):
                 scope, rest = self._follow_file_system()
             except ModuleNotFound:
                 debug.warning('Module not found: ' + str(self.import_stmt))
-                self._evaluator.follow_statement.pop_stmt()
+                self._evaluator.recursion_detector.pop_stmt()
                 return []
 
             scopes = [scope]
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index dee8a273..c69b2439 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -506,7 +506,7 @@ class Execution(Executable):
         for listener in func.listeners:
             listener.execute(self._get_params())
         if func.is_generator and not evaluate_generator:
-            return [Generator(func, self.var_args)]
+            return [Generator(self._evaluator, func, self.var_args)]
         else:
             """
             stmts = docstrings.find_return_types(func)

From 3c28b1907c5b5213c6372db9f7468fec195aa9df Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 22:49:57 +0100
Subject: [PATCH 21/42] dynamic belongs also into the evaluate folder

---
 jedi/{ => evaluate}/dynamic.py | 2 --
 1 file changed, 2 deletions(-)
 rename jedi/{ => evaluate}/dynamic.py (99%)

diff --git a/jedi/dynamic.py b/jedi/evaluate/dynamic.py
similarity index 99%
rename from jedi/dynamic.py
rename to jedi/evaluate/dynamic.py
index 8bbda015..9b330b6c 100644
--- a/jedi/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -51,8 +51,6 @@ would check whether a flow has the form of ``if isinstance(a, type_or_tuple)``.
 Unfortunately every other thing is being ignored (e.g. a == '' would be easy to
 check for -> a is a string). There's big potential in these checks.
 """
-from __future__ import with_statement
-
 import os
 
 from jedi import cache

From dd804dc4cb2a64dcc7699ed5a0dbd78fa8848898 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 24 Dec 2013 22:54:03 +0100
Subject: [PATCH 22/42] move the usages stuff away from dynamic

---
 jedi/api.py              | 80 ++++++++++++++++++++++++++++++++++++++++
 jedi/evaluate/dynamic.py | 79 ---------------------------------------
 2 files changed, 80 insertions(+), 79 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index 8b4ebec5..6092e10d 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -700,3 +700,83 @@ def set_debug_function(func_cb=debug.print_to_stdout, warnings=True,
     debug.enable_warning = warnings
     debug.enable_notice = notices
     debug.enable_speed = speed
+
+
+# TODO move to a better place.
+def usages(definitions, search_name, mods):
+    def compare_array(definitions):
+        """ `definitions` are being compared by module/start_pos, because
+        sometimes the id's of the objects change (e.g. executions).
+        """
+        result = []
+        for d in definitions:
+            module = d.get_parent_until()
+            result.append((module, d.start_pos))
+        return result
+
+    def check_call(call):
+        result = []
+        follow = []  # There might be multiple search_name's in one call_path
+        call_path = list(call.generate_call_path())
+        for i, name in enumerate(call_path):
+            # name is `pr.NamePart`.
+            if name == search_name:
+                follow.append(call_path[:i + 1])
+
+        for f in follow:
+            follow_res, search = evaluate.goto(call.parent, f)
+            follow_res = usages_add_import_modules(follow_res, search)
+
+            compare_follow_res = compare_array(follow_res)
+            # compare to see if they match
+            if any(r in compare_definitions for r in compare_follow_res):
+                scope = call.parent
+                result.append(api_classes.Usage(search, scope))
+
+        return result
+
+    if not definitions:
+        return set()
+
+    compare_definitions = compare_array(definitions)
+    mods |= set([d.get_parent_until() for d in definitions])
+    names = []
+    for m in get_directory_modules_for_name(mods, search_name):
+        try:
+            stmts = m.used_names[search_name]
+        except KeyError:
+            continue
+        for stmt in stmts:
+            if isinstance(stmt, pr.Import):
+                count = 0
+                imps = []
+                for i in stmt.get_all_import_names():
+                    for name_part in i.names:
+                        count += 1
+                        if name_part == search_name:
+                            imps.append((count, name_part))
+
+                for used_count, name_part in imps:
+                    i = imports.ImportPath(_evaluator, stmt, kill_count=count - used_count,
+                                           direct_resolve=True)
+                    f = i.follow(is_goto=True)
+                    if set(f) & set(definitions):
+                        names.append(api_classes.Usage(name_part, stmt))
+            else:
+                for call in _scan_statement(stmt, search_name,
+                                            assignment_details=True):
+                    names += check_call(call)
+    return names
+
+
+def usages_add_import_modules(definitions, search_name):
+    """ Adds the modules of the imports """
+    new = set()
+    for d in definitions:
+        if isinstance(d.parent, pr.Import):
+            s = imports.ImportPath(_evaluator, d.parent, direct_resolve=True)
+            with common.ignored(IndexError):
+                new.add(s.follow(is_goto=True)[0])
+    return set(definitions) | new
+
+
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index 9b330b6c..cf688eac 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -57,10 +57,8 @@ from jedi import cache
 from jedi.parser import representation as pr
 from jedi import modules
 from jedi import settings
-from jedi import common
 from jedi import debug
 from jedi.parser import fast as fast_parser
-from jedi.evaluate import imports
 from jedi.evaluate.cache import memoize_default
 
 # This is something like the sys.path, but only for searching params. It means
@@ -449,83 +447,6 @@ class ArrayInstance(pr.Base):
         return items
 
 
-def usages(definitions, search_name, mods):
-    def compare_array(definitions):
-        """ `definitions` are being compared by module/start_pos, because
-        sometimes the id's of the objects change (e.g. executions).
-        """
-        result = []
-        for d in definitions:
-            module = d.get_parent_until()
-            result.append((module, d.start_pos))
-        return result
-
-    def check_call(call):
-        result = []
-        follow = []  # There might be multiple search_name's in one call_path
-        call_path = list(call.generate_call_path())
-        for i, name in enumerate(call_path):
-            # name is `pr.NamePart`.
-            if name == search_name:
-                follow.append(call_path[:i + 1])
-
-        for f in follow:
-            follow_res, search = evaluate.goto(call.parent, f)
-            follow_res = usages_add_import_modules(follow_res, search)
-
-            compare_follow_res = compare_array(follow_res)
-            # compare to see if they match
-            if any(r in compare_definitions for r in compare_follow_res):
-                scope = call.parent
-                result.append(api_classes.Usage(search, scope))
-
-        return result
-
-    if not definitions:
-        return set()
-
-    compare_definitions = compare_array(definitions)
-    mods |= set([d.get_parent_until() for d in definitions])
-    names = []
-    for m in get_directory_modules_for_name(mods, search_name):
-        try:
-            stmts = m.used_names[search_name]
-        except KeyError:
-            continue
-        for stmt in stmts:
-            if isinstance(stmt, pr.Import):
-                count = 0
-                imps = []
-                for i in stmt.get_all_import_names():
-                    for name_part in i.names:
-                        count += 1
-                        if name_part == search_name:
-                            imps.append((count, name_part))
-
-                for used_count, name_part in imps:
-                    i = imports.ImportPath(_evaluator, stmt, kill_count=count - used_count,
-                                           direct_resolve=True)
-                    f = i.follow(is_goto=True)
-                    if set(f) & set(definitions):
-                        names.append(api_classes.Usage(name_part, stmt))
-            else:
-                for call in _scan_statement(stmt, search_name,
-                                            assignment_details=True):
-                    names += check_call(call)
-    return names
-
-
-def usages_add_import_modules(definitions, search_name):
-    """ Adds the modules of the imports """
-    new = set()
-    for d in definitions:
-        if isinstance(d.parent, pr.Import):
-            s = imports.ImportPath(_evaluator, d.parent, direct_resolve=True)
-            with common.ignored(IndexError):
-                new.add(s.follow(is_goto=True)[0])
-    return set(definitions) | new
-
-
 def check_flow_information(flow, search_name, pos):
     """ Try to find out the type of a variable just with the information that
     is given by the flows: e.g. It is also responsible for assert checks.::

From ef764d39d85f9fefc8afd3057eb743d37bbc1f23 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 01:54:51 +0100
Subject: [PATCH 23/42] evaluator stuff for dynamic

---
 jedi/api.py                     |  4 ++--
 jedi/api_classes.py             |  2 +-
 jedi/docstrings.py              |  6 +++---
 jedi/evaluate/__init__.py       |  4 ++--
 jedi/evaluate/cache.py          |  7 +++++--
 jedi/evaluate/dynamic.py        | 20 ++++++++++----------
 jedi/evaluate/representation.py |  2 +-
 7 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index 6092e10d..3e38db7d 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -30,8 +30,8 @@ from jedi.evaluate import representation as er
 from jedi import keywords
 from jedi.evaluate import builtin
 from jedi.evaluate import imports
-import api_classes
-import dynamic
+from jedi.evaluate import dynamic
+from jedi import api_classes
 
 
 class NotFoundError(Exception):
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index d927cb23..b08f5ef7 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -14,7 +14,7 @@ from jedi import cache
 from jedi.evaluate import representation as er
 from jedi.evaluate import imports
 from jedi import keywords
-import dynamic
+from jedi.evaluate import dynamic
 
 
 def _clear_caches():
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 477f999d..4d81a357 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -32,8 +32,8 @@ DOCSTRING_RETURN_PATTERNS = [
 REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
 
 
-@memoize_default(None)
-def follow_param(param):
+@memoize_default(None, is_function=True)
+def follow_param(evaluator, param):
     func = param.parent_function
     # print func, param, param.parent_function
     param_str = _search_param_in_docstr(func.docstr, str(param.get_name()))
@@ -52,7 +52,7 @@ def follow_param(param):
         p = Parser(param_str, None, user_position, no_docstr=True)
         if p.user_stmt is None:
             return []
-        return evaluate.follow_statement(p.user_stmt)
+        return evaluator.follow_statement(p.user_stmt)
     return []
 
 
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 86432196..84cafded 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -83,7 +83,7 @@ from jedi.evaluate import imports
 from jedi.evaluate import recursion
 from jedi.evaluate.cache import memoize_default
 from jedi import docstrings
-from jedi import dynamic
+from jedi.evaluate import dynamic
 
 
 def get_defined_names_for_position(scope, position=None, start_scope=None):
@@ -263,7 +263,7 @@ class Evaluator(object):
                                 """
 
                             if not r.is_generated:
-                                res_new += dynamic.search_params(r)
+                                res_new += dynamic.search_params(self, r)
                                 if not res_new:
                                     c = r.get_commands()[0]
                                     if c in ('*', '**'):
diff --git a/jedi/evaluate/cache.py b/jedi/evaluate/cache.py
index 44526373..4d338820 100644
--- a/jedi/evaluate/cache.py
+++ b/jedi/evaluate/cache.py
@@ -5,7 +5,8 @@
 """
 
 
-def memoize_default(default, cache_is_in_self=False, first_arg_is_evaluator=False):
+def memoize_default(default, cache_is_in_self=False, is_function=False,
+                    first_arg_is_evaluator=False):
     """ This is a typical memoization decorator, BUT there is one difference:
     To prevent recursion it sets defaults.
 
@@ -15,7 +16,9 @@ def memoize_default(default, cache_is_in_self=False, first_arg_is_evaluator=Fals
     """
     def func(function):
         def wrapper(obj, *args, **kwargs):
-            if cache_is_in_self:
+            if is_function:
+                cache = obj
+            elif cache_is_in_self:
                 cache = obj.memoize_cache
             elif first_arg_is_evaluator:  # needed for meta classes
                 cache = args[0].memoize_cache
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index cf688eac..603f8094 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -110,7 +110,7 @@ def get_directory_modules_for_name(mods, name):
                 yield c
 
 
-def search_param_memoize(func):
+def _search_param_memoize(func):
     """
     Is only good for search params memoize, respectively the closure,
     because it just caches the input, not the func, like normal memoize does.
@@ -137,8 +137,8 @@ class ParamListener(object):
         self.param_possibilities.append(params)
 
 
-@memoize_default([])
-def search_params(param):
+@memoize_default([], is_function=True)
+def search_params(evaluator, param):
     """
     This is a dynamic search for params. If you try to complete a type:
 
@@ -158,7 +158,7 @@ def search_params(param):
         """
         Returns the values of a param, or an empty array.
         """
-        @search_param_memoize
+        @_search_param_memoize
         def get_posibilities(module, func_name):
             try:
                 possible_stmts = module.used_names[func_name]
@@ -190,12 +190,12 @@ def search_params(param):
                         continue
                     scopes = [scope]
                     if first:
-                        scopes = evaluate.follow_call_path(iter(first), scope, pos)
+                        scopes = evaluator.follow_call_path(iter(first), scope, pos)
                         pos = None
                     for scope in scopes:
-                        s = evaluate.find_name(scope, func_name, position=pos,
-                                               search_global=not first,
-                                               resolve_decorator=False)
+                        s = evaluator.find_name(scope, func_name, position=pos,
+                                                search_global=not first,
+                                                resolve_decorator=False)
 
                         c = [getattr(escope, 'base_func', None) or escope.base
                              for escope in s
@@ -203,7 +203,7 @@ def search_params(param):
                         if compare in c:
                             # only if we have the correct function we execute
                             # it, otherwise just ignore it.
-                            evaluate.follow_paths(iter(last), s, scope)
+                            evaluator.follow_paths(iter(last), s, scope)
 
             return listener.param_possibilities
 
@@ -211,7 +211,7 @@ def search_params(param):
         for params in get_posibilities(module, func_name):
             for p in params:
                 if str(p) == param_name:
-                    result += evaluate.follow_statement(p.parent)
+                    result += evaluator.follow_statement(p.parent)
         return result
 
     func = param.get_parent_until(pr.Function)
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index c69b2439..b54e09f8 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -25,7 +25,7 @@ from jedi.evaluate import recursion
 from jedi.evaluate.cache import memoize_default, CachedMetaClass
 from jedi.evaluate.interfaces import Iterable
 from jedi import docstrings
-from jedi import dynamic
+from jedi.evaluate import dynamic
 
 
 class Executable(pr.IsScope):

From 4cf5d56b64cbef58d2e66f054aa6ffbfa3516ffd Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 03:24:12 +0100
Subject: [PATCH 24/42] fix more issues and renamings

---
 jedi/cache.py             |  4 ++--
 jedi/docstrings.py        |  2 +-
 jedi/evaluate/__init__.py |  2 +-
 jedi/evaluate/cache.py    | 11 ++++-------
 jedi/evaluate/dynamic.py  |  2 +-
 5 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/jedi/cache.py b/jedi/cache.py
index 918af40d..37f7a961 100644
--- a/jedi/cache.py
+++ b/jedi/cache.py
@@ -103,14 +103,14 @@ def cache_call_signatures(stmt):
 
 
 def cache_star_import(func):
-    def wrapper(scope, *args, **kwargs):
+    def wrapper(evaluator, scope, *args, **kwargs):
         with common.ignored(KeyError):
             mods = star_import_cache[scope]
             if mods[0] + settings.star_import_cache_validity > time.time():
                 return mods[1]
         # cache is too old and therefore invalid or not available
         invalidate_star_import_cache(scope)
-        mods = func(scope, *args, **kwargs)
+        mods = func(evaluator, scope, *args, **kwargs)
         star_import_cache[scope] = time.time(), mods
 
         return mods
diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 4d81a357..2a9c0b34 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -32,7 +32,7 @@ DOCSTRING_RETURN_PATTERNS = [
 REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
 
 
-@memoize_default(None, is_function=True)
+@memoize_default(None, evaluator_is_first_arg=True)
 def follow_param(evaluator, param):
     func = param.parent_function
     # print func, param, param.parent_function
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 84cafded..9e65715b 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -477,7 +477,7 @@ class Evaluator(object):
             return filter_name(scope_generator)
         return descriptor_check(remove_statements(filter_name(scope_generator)))
 
-    @memoize_default(default=(), cache_is_in_self=True)
+    @memoize_default(default=(), evaluator_is_first_arg=True)
     @recursion.recursion_decorator
     def follow_statement(self, stmt, seek_name=None):
         """
diff --git a/jedi/evaluate/cache.py b/jedi/evaluate/cache.py
index 4d338820..1f58ae34 100644
--- a/jedi/evaluate/cache.py
+++ b/jedi/evaluate/cache.py
@@ -5,8 +5,7 @@
 """
 
 
-def memoize_default(default, cache_is_in_self=False, is_function=False,
-                    first_arg_is_evaluator=False):
+def memoize_default(default, evaluator_is_first_arg=False, second_arg_is_evaluator=False):
     """ This is a typical memoization decorator, BUT there is one difference:
     To prevent recursion it sets defaults.
 
@@ -16,11 +15,9 @@ def memoize_default(default, cache_is_in_self=False, is_function=False,
     """
     def func(function):
         def wrapper(obj, *args, **kwargs):
-            if is_function:
-                cache = obj
-            elif cache_is_in_self:
+            if evaluator_is_first_arg:
                 cache = obj.memoize_cache
-            elif first_arg_is_evaluator:  # needed for meta classes
+            elif second_arg_is_evaluator:  # needed for meta classes
                 cache = args[0].memoize_cache
             else:
                 cache = obj._evaluator.memoize_cache
@@ -49,6 +46,6 @@ class CachedMetaClass(type):
     class initializations. I haven't found any other way, so I'm doing it with
     meta classes.
     """
-    @memoize_default(None, first_arg_is_evaluator=True)
+    @memoize_default(None, second_arg_is_evaluator=True)
     def __call__(self, *args, **kwargs):
         return super(CachedMetaClass, self).__call__(*args, **kwargs)
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index 603f8094..d684a28d 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -137,7 +137,7 @@ class ParamListener(object):
         self.param_possibilities.append(params)
 
 
-@memoize_default([], is_function=True)
+@memoize_default([], evaluator_is_first_arg=True)
 def search_params(evaluator, param):
     """
     This is a dynamic search for params. If you try to complete a type:

From b768e214eb0a2c0c675270aea77a032f4069f15e Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 15:19:12 +0100
Subject: [PATCH 25/42] fix cache memoization

---
 jedi/evaluate/cache.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jedi/evaluate/cache.py b/jedi/evaluate/cache.py
index 1f58ae34..d686f894 100644
--- a/jedi/evaluate/cache.py
+++ b/jedi/evaluate/cache.py
@@ -28,7 +28,7 @@ def memoize_default(default, evaluator_is_first_arg=False, second_arg_is_evaluat
                 memo = {}
                 cache[function] = memo
 
-            key = (args, frozenset(kwargs.items()))
+            key = (obj, args, frozenset(kwargs.items()))
             if key in memo:
                 return memo[key]
             else:

From 5d486f0e3cdb224bd5622ff5901b84c701551842 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 18:16:40 +0100
Subject: [PATCH 26/42] fix a lot of the dynamic issues

---
 jedi/evaluate/__init__.py       |  4 +--
 jedi/evaluate/dynamic.py        | 46 +++++++++++++++++++--------------
 jedi/evaluate/representation.py |  6 ++---
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 9e65715b..c8fc5f1d 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -424,8 +424,8 @@ class Evaluator(object):
 
                 while flow_scope:
                     # TODO check if result is in scope -> no evaluation necessary
-                    n = dynamic.check_flow_information(flow_scope, name_str,
-                                                       position)
+                    n = dynamic.check_flow_information(self, flow_scope,
+                                                       name_str, position)
                     if n:
                         result = n
                         break
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index d684a28d..87ec0b5c 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -192,6 +192,7 @@ def search_params(evaluator, param):
                     if first:
                         scopes = evaluator.follow_call_path(iter(first), scope, pos)
                         pos = None
+                    from jedi.evaluate import representation as er
                     for scope in scopes:
                         s = evaluator.find_name(scope, func_name, position=pos,
                                                 search_global=not first,
@@ -248,7 +249,7 @@ def search_params(evaluator, param):
     return result
 
 
-def check_array_additions(array):
+def check_array_additions(evaluator, array):
     """ Just a mapper function for the internal _check_array_additions """
     if not pr.Array.is_type(array._array, pr.Array.LIST, pr.Array.SET):
         # TODO also check for dict updates
@@ -296,8 +297,8 @@ def _scan_statement(stmt, search_name, assignment_details=False):
     return result
 
 
-@memoize_default([])
-def _check_array_additions(compare_array, module, is_list):
+@memoize_default([], evaluator_is_first_arg=True)
+def _check_array_additions(evaluator, compare_array, module, is_list):
     """
     Checks if a `pr.Array` has "add" statements:
     >>> a = [""]
@@ -324,7 +325,7 @@ def _check_array_additions(compare_array, module, is_list):
             position = c.start_pos
             scope = c.get_parent_until(pr.IsScope)
 
-            found = evaluate.follow_call_path(backtrack_path, scope, position)
+            found = evaluator.follow_call_path(backtrack_path, scope, position)
             if not compare_array in found:
                 continue
 
@@ -333,20 +334,22 @@ def _check_array_additions(compare_array, module, is_list):
                 continue  # no params: just ignore it
             if add_name in ['append', 'add']:
                 for param in params:
-                    result += evaluate.follow_statement(param)
+                    result += evaluator.follow_statement(param)
             elif add_name in ['insert']:
                 try:
                     second_param = params[1]
                 except IndexError:
                     continue
                 else:
-                    result += evaluate.follow_statement(second_param)
+                    result += evaluator.follow_statement(second_param)
             elif add_name in ['extend', 'update']:
                 for param in params:
-                    iterators = evaluate.follow_statement(param)
-                result += evaluate.get_iterator_types(iterators)
+                    iterators = evaluator.follow_statement(param)
+                result += evaluator.get_iterator_types(iterators)
         return result
 
+    from jedi.evaluate import representation as er
+
     def get_execution_parent(element, *stop_classes):
         """ Used to get an Instance/Execution parent """
         if isinstance(element, er.Array):
@@ -387,21 +390,21 @@ def _check_array_additions(compare_array, module, is_list):
             if isinstance(comp_arr_parent, er.InstanceElement):
                 stmt = er.InstanceElement(comp_arr_parent.instance, stmt)
 
-            if evaluate.follow_statement.push_stmt(stmt):
+            if evaluator.follow_statement.push_stmt(stmt):
                 # check recursion
                 continue
             res += check_calls(_scan_statement(stmt, n), n)
-            evaluate.follow_statement.pop_stmt()
+            evaluator.follow_statement.pop_stmt()
     # reset settings
     settings.dynamic_params_for_other_modules = temp_param_add
     return res
 
 
-def check_array_instances(instance):
+def check_array_instances(evaluator, instance):
     """Used for set() and list() instances."""
     if not settings.dynamic_arrays_instances:
         return instance.var_args
-    ai = ArrayInstance(instance)
+    ai = ArrayInstance(evaluator, instance)
     return [ai]
 
 
@@ -411,7 +414,8 @@ class ArrayInstance(pr.Base):
     This is definitely a hack, but a good one :-)
     It makes it possible to use set/list conversions.
     """
-    def __init__(self, instance):
+    def __init__(self, evaluator, instance):
+        self._evaluator = evaluator
         self.instance = instance
         self.var_args = instance.var_args
 
@@ -421,8 +425,9 @@ class ArrayInstance(pr.Base):
         lists/sets are too complicated too handle that.
         """
         items = []
+        from jedi.evaluate import representation as er
         for stmt in self.var_args:
-            for typ in evaluate.follow_statement(stmt):
+            for typ in self._evaluator.follow_statement(stmt):
                 if isinstance(typ, er.Instance) and len(typ.var_args):
                     array = typ.var_args[0]
                     if isinstance(array, ArrayInstance):
@@ -435,7 +440,7 @@ class ArrayInstance(pr.Base):
                                 'ArrayInstance recursion',
                                 self.var_args)
                         continue
-                items += evaluate.get_iterator_types([typ])
+                items += self._evaluator.get_iterator_types([typ])
 
         # TODO check if exclusion of tuple is a problem here.
         if isinstance(self.var_args, tuple) or self.var_args.parent is None:
@@ -447,7 +452,7 @@ class ArrayInstance(pr.Base):
         return items
 
 
-def check_flow_information(flow, search_name, pos):
+def check_flow_information(evaluator, flow, search_name, pos):
     """ Try to find out the type of a variable just with the information that
     is given by the flows: e.g. It is also responsible for assert checks.::
 
@@ -463,17 +468,18 @@ def check_flow_information(flow, search_name, pos):
         for ass in reversed(flow.asserts):
             if pos is None or ass.start_pos > pos:
                 continue
-            result = _check_isinstance_type(ass, search_name)
+            result = _check_isinstance_type(evaluator, ass, search_name)
             if result:
                 break
 
     if isinstance(flow, pr.Flow) and not result:
         if flow.command in ['if', 'while'] and len(flow.inputs) == 1:
-            result = _check_isinstance_type(flow.inputs[0], search_name)
+            result = _check_isinstance_type(evaluator, flow.inputs[0], search_name)
     return result
 
 
-def _check_isinstance_type(stmt, search_name):
+def _check_isinstance_type(evaluator, stmt, search_name):
+    from jedi.evaluate import representation as er
     try:
         commands = stmt.get_commands()
         # this might be removed if we analyze and, etc
@@ -496,7 +502,7 @@ def _check_isinstance_type(stmt, search_name):
         return []
 
     result = []
-    for c in evaluate.follow_call(classes[0]):
+    for c in evaluator.follow_call(classes[0]):
         if isinstance(c, er.Array):
             result += c.get_index_types()
         else:
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index b54e09f8..c5e7a127 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -62,7 +62,7 @@ class Instance(use_metaclass(CachedMetaClass, Executable)):
         if str(base.name) in ['list', 'set'] \
                 and builtin.Builtin.scope == base.get_parent_until():
             # compare the module path with the builtin name.
-            self.var_args = dynamic.check_array_instances(self)
+            self.var_args = dynamic.check_array_instances(evaluator, self)
         else:
             # need to execute the __init__ function, because the dynamic param
             # searching needs it.
@@ -785,8 +785,8 @@ class Execution(Executable):
 class Generator(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
     """ Cares for `yield` statements. """
     def __init__(self, evaluator, func, var_args):
-        # Need evaluator for `CachedMetaClass`.
         super(Generator, self).__init__()
+        self._evaluator = evaluator
         self.func = func
         self.var_args = var_args
 
@@ -860,7 +860,7 @@ class Array(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
                         return self.get_exact_index_types(index.var_args[0])
 
         result = list(self._follow_values(self._array.values))
-        result += dynamic.check_array_additions(self)
+        result += dynamic.check_array_additions(evaluator, self)
         return set(result)
 
     def get_exact_index_types(self, mixed_index):

From d86f180d2e869ad357ff3e282e9ac0f5fc0b220b Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 18:28:56 +0100
Subject: [PATCH 27/42] bug fixes for dynamic/iterator stuff

---
 jedi/docstrings.py              |  2 +-
 jedi/evaluate/builtin.py        |  5 ++---
 jedi/evaluate/dynamic.py        | 13 +++++++------
 jedi/evaluate/representation.py |  6 +++---
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index 2a9c0b34..bfe420e2 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -104,7 +104,7 @@ def _strip_rest_role(type_str):
         return type_str
 
 
-def find_return_types(func):
+def find_return_types(evaluator, func):
     def search_return_in_docstr(code):
         for p in DOCSTRING_RETURN_PATTERNS:
             match = p.search(code)
diff --git a/jedi/evaluate/builtin.py b/jedi/evaluate/builtin.py
index 4fa7ce04..a0bc7e18 100644
--- a/jedi/evaluate/builtin.py
+++ b/jedi/evaluate/builtin.py
@@ -428,8 +428,7 @@ class Builtin(object):
     def scope(self):
         return self.builtin.parser.module
 
-    @property
-    def magic_function_scope(self):
+    def magic_function_scope(self, evaluator):
         try:
             return self._magic_function_scope
         except AttributeError:
@@ -440,7 +439,7 @@ class Builtin(object):
             parser = Parser(source, None)
             module = parser.module
             module.parent = self.scope
-            typ = evaluate.follow_path(iter(['FunctionType']), module, module)
+            typ = evaluator.follow_path(iter(['FunctionType']), module, module)
 
             s = self._magic_function_scope = typ.pop()
             return s
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index 87ec0b5c..9da574d9 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -257,7 +257,7 @@ def check_array_additions(evaluator, array):
 
     is_list = array._array.type == 'list'
     current_module = array._array.get_parent_until()
-    res = _check_array_additions(array, current_module, is_list)
+    res = _check_array_additions(evaluator, array, current_module, is_list)
     return res
 
 
@@ -345,10 +345,11 @@ def _check_array_additions(evaluator, compare_array, module, is_list):
             elif add_name in ['extend', 'update']:
                 for param in params:
                     iterators = evaluator.follow_statement(param)
-                result += evaluator.get_iterator_types(iterators)
+                result += evaluate.get_iterator_types(iterators)
         return result
 
     from jedi.evaluate import representation as er
+    from jedi import evaluate
 
     def get_execution_parent(element, *stop_classes):
         """ Used to get an Instance/Execution parent """
@@ -425,10 +426,10 @@ class ArrayInstance(pr.Base):
         lists/sets are too complicated too handle that.
         """
         items = []
-        from jedi.evaluate import representation as er
+        from jedi import evaluate
         for stmt in self.var_args:
             for typ in self._evaluator.follow_statement(stmt):
-                if isinstance(typ, er.Instance) and len(typ.var_args):
+                if isinstance(typ, evaluate.er.Instance) and len(typ.var_args):
                     array = typ.var_args[0]
                     if isinstance(array, ArrayInstance):
                         # prevent recursions
@@ -440,7 +441,7 @@ class ArrayInstance(pr.Base):
                                 'ArrayInstance recursion',
                                 self.var_args)
                         continue
-                items += self._evaluator.get_iterator_types([typ])
+                items += evaluate.get_iterator_types([typ])
 
         # TODO check if exclusion of tuple is a problem here.
         if isinstance(self.var_args, tuple) or self.var_args.parent is None:
@@ -448,7 +449,7 @@ class ArrayInstance(pr.Base):
 
         module = self.var_args.get_parent_until()
         is_list = str(self.instance.name) == 'list'
-        items += _check_array_additions(self.instance, module, is_list)
+        items += _check_array_additions(self._evaluator, self.instance, module, is_list)
         return items
 
 
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index c5e7a127..e796eee1 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -384,10 +384,10 @@ class Function(use_metaclass(CachedMetaClass, pr.IsScope)):
         return decorated_func
 
     def get_magic_method_names(self):
-        return builtin.Builtin.magic_function_scope.get_defined_names()
+        return builtin.Builtin.magic_function_scope(self._evaluator).get_defined_names()
 
     def get_magic_method_scope(self):
-        return builtin.Builtin.magic_function_scope
+        return builtin.Builtin.magic_function_scope(self._evaluator)
 
     def __getattr__(self, name):
         return getattr(self.base_func, name)
@@ -860,7 +860,7 @@ class Array(use_metaclass(CachedMetaClass, pr.Base, Iterable)):
                         return self.get_exact_index_types(index.var_args[0])
 
         result = list(self._follow_values(self._array.values))
-        result += dynamic.check_array_additions(evaluator, self)
+        result += dynamic.check_array_additions(self._evaluator, self)
         return set(result)
 
     def get_exact_index_types(self, mixed_index):

From f039bc3fc97a5e122566c6f5620a22a26b683810 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 18:31:42 +0100
Subject: [PATCH 28/42] fix docstrings with evaluator stuff

---
 jedi/docstrings.py              | 4 +++-
 jedi/evaluate/__init__.py       | 4 +---
 jedi/evaluate/representation.py | 5 +----
 3 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/jedi/docstrings.py b/jedi/docstrings.py
index bfe420e2..9f9cefba 100644
--- a/jedi/docstrings.py
+++ b/jedi/docstrings.py
@@ -111,6 +111,8 @@ def find_return_types(evaluator, func):
             if match:
                 return match.group(1)
 
+    from jedi.evaluate import representation as er
+
     if isinstance(func, er.InstanceElement):
         func = func.var
 
@@ -125,4 +127,4 @@ def find_return_types(evaluator, func):
     if p.user_stmt is None:
         return []
     p.user_stmt.parent = func
-    return list(evaluate.follow_statement(p.user_stmt))
+    return list(evaluator.follow_statement(p.user_stmt))
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index c8fc5f1d..9e75ea8e 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -255,12 +255,10 @@ class Evaluator(object):
                                 r = func.var.params[r.position_nr]
 
                             # add docstring knowledge
-                            """
-                            doc_params = docstrings.follow_param(r) TODO ENABLE
+                            doc_params = docstrings.follow_param(self, r)
                             if doc_params:
                                 res_new += doc_params
                                 continue
-                                """
 
                             if not r.is_generated:
                                 res_new += dynamic.search_params(self, r)
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index e796eee1..150ee42a 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -508,10 +508,7 @@ class Execution(Executable):
         if func.is_generator and not evaluate_generator:
             return [Generator(self._evaluator, func, self.var_args)]
         else:
-            """
-            stmts = docstrings.find_return_types(func)
-            """
-            stmts=[]
+            stmts = docstrings.find_return_types(self._evaluator, func)
             for r in self.returns:
                 if r is not None:
                     stmts += self._evaluator.follow_statement(r)

From 002b7001cae9d4b1cb5bcd5e87ae0a9e364330be Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 18:38:23 +0100
Subject: [PATCH 29/42] pass more than half of the integration tests, more
 bugfixes

---
 jedi/evaluate/dynamic.py        | 4 ++--
 jedi/evaluate/representation.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index 9da574d9..edaa1edb 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -391,11 +391,11 @@ def _check_array_additions(evaluator, compare_array, module, is_list):
             if isinstance(comp_arr_parent, er.InstanceElement):
                 stmt = er.InstanceElement(comp_arr_parent.instance, stmt)
 
-            if evaluator.follow_statement.push_stmt(stmt):
+            if evaluator.recursion_detector.push_stmt(stmt):
                 # check recursion
                 continue
             res += check_calls(_scan_statement(stmt, n), n)
-            evaluator.follow_statement.pop_stmt()
+            evaluator.recursion_detector.pop_stmt()
     # reset settings
     settings.dynamic_params_for_other_modules = temp_param_add
     return res
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 150ee42a..1ff0f4f9 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -199,7 +199,7 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
         if isinstance(var, pr.Function):
             var = Function(evaluator, var)
         elif isinstance(var, pr.Class):
-            var = Class(var)
+            var = Class(evaluator, var)
         self.instance = instance
         self.var = var
         self.is_class_var = is_class_var
@@ -470,7 +470,7 @@ class Execution(Executable):
                     cls = func.get_parent_until(accept + (pr.Class,),
                                                 include_current=False)
                     if isinstance(cls, pr.Class):
-                        cls = Class(cls)
+                        cls = Class(self._evaluator, cls)
                         su = cls.get_super_classes()
                         if su:
                             return [Instance(self._evaluator, su[0])]

From 05f7e6f4b5f95ed66e42fd12f49c272c91a44ea4 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 18:48:04 +0100
Subject: [PATCH 30/42] import changes so that all local imports are 'from
 jedi.* import *'

---
 jedi/__init__.py              | 6 +++---
 jedi/debug.py                 | 2 +-
 jedi/interpret.py             | 2 +-
 jedi/parser/representation.py | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/jedi/__init__.py b/jedi/__init__.py
index 4763d6c4..9a41f275 100644
--- a/jedi/__init__.py
+++ b/jedi/__init__.py
@@ -36,6 +36,6 @@ good text editor, while still having very good IDE features for Python.
 
 __version__ = 0, 7, 1, 'alpha1'
 
-from .api import Script, Interpreter, NotFoundError, set_debug_function
-from .api import preload_module, defined_names
-from . import settings
+from jedi.api import Script, Interpreter, NotFoundError, set_debug_function
+from jedi.api import preload_module, defined_names
+from jedi import settings
diff --git a/jedi/debug.py b/jedi/debug.py
index d4ab9106..42edd3ce 100644
--- a/jedi/debug.py
+++ b/jedi/debug.py
@@ -1,4 +1,4 @@
-from _compatibility import u, encoding, is_py3k
+from jedi._compatibility import u, encoding, is_py3k
 import inspect
 import time
 
diff --git a/jedi/interpret.py b/jedi/interpret.py
index 2a7bc85d..1e17c05f 100644
--- a/jedi/interpret.py
+++ b/jedi/interpret.py
@@ -3,9 +3,9 @@ Module to handle interpreted Python objects.
 """
 
 import itertools
-import tokenize
 
 from jedi.parser import representation as pr
+from jedi.parser import tokenizer as tokenize
 from jedi.parser import token
 
 
diff --git a/jedi/parser/representation.py b/jedi/parser/representation.py
index c0e931f6..ca796187 100644
--- a/jedi/parser/representation.py
+++ b/jedi/parser/representation.py
@@ -37,13 +37,13 @@ from __future__ import with_statement
 
 import os
 import re
-import tokenizer as tokenize
 from inspect import cleandoc
 from ast import literal_eval
 
 from jedi._compatibility import next, Python3Method, encoding, unicode, is_py3k
 from jedi import common
 from jedi import debug
+from jedi.parser import tokenizer as tokenize
 
 
 class Base(object):

From 4aa8be78296a8db8e8ff839945b3728897b125ef Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Wed, 25 Dec 2013 19:08:28 +0100
Subject: [PATCH 31/42] include jedi.evaluate as a package in setup.py

---
 setup.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index 9bdda0be..e01ea656 100755
--- a/setup.py
+++ b/setup.py
@@ -26,7 +26,7 @@ setup(name='jedi',
       license='MIT',
       keywords='python completion refactoring vim',
       long_description=readme,
-      packages=['jedi', 'jedi.parser'],
+      packages=['jedi', 'jedi.parser', 'jedi.evaluate'],
       package_data={'jedi': ['mixin/*.pym']},
       platforms=['any'],
       classifiers=[
@@ -45,4 +45,4 @@ setup(name='jedi',
           'Topic :: Text Editors :: Integrated Development Environments (IDE)',
           'Topic :: Utilities',
       ],
-    )
+      )

From 947e616da0532794a059c61f462e95cfa42a9578 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Thu, 26 Dec 2013 01:00:37 +0100
Subject: [PATCH 32/42] hand api classes the evaluator

---
 jedi/api.py          | 36 +++++++++++++++++-------------------
 jedi/api_classes.py  | 25 +++++++++++++------------
 test/test_builtin.py |  2 +-
 3 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index 3e38db7d..a18cc745 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -162,7 +162,7 @@ class Script(object):
                     or n.startswith(like):
                 if not filter_private_variable(s,
                             user_stmt or self._parser.user_scope, n):
-                    new = api_classes.Completion(c, needs_dot, len(like), s)
+                    new = api_classes.Completion(self._evaluator, c, needs_dot, len(like), s)
                     k = (new.name, new.complete)  # key
                     if k in comp_dct and settings.no_completion_duplicates:
                         comp_dct[k]._same_name_completions.append(new)
@@ -379,7 +379,7 @@ class Script(object):
         # add keywords
         scopes |= keywords.keywords(string=goto_path, pos=self._pos)
 
-        d = set([api_classes.Definition(s) for s in scopes
+        d = set([api_classes.Definition(self._evaluator, s) for s in scopes
                  if s is not imports.ImportPath.GlobalNamespace])
         return self._sorted_defs(d)
 
@@ -394,7 +394,7 @@ class Script(object):
         :rtype: list of :class:`api_classes.Definition`
         """
         results, _ = self._goto()
-        d = [api_classes.Definition(d) for d in set(results)
+        d = [api_classes.Definition(self._evaluator, d) for d in set(results)
              if d is not imports.ImportPath.GlobalNamespace]
         return self._sorted_defs(d)
 
@@ -482,17 +482,17 @@ class Script(object):
 
         module = set([d.get_parent_until() for d in definitions])
         module.add(self._parser.module)
-        names = dynamic.usages(definitions, search_name, module)
+        names = usages(self._evaluator, definitions, search_name, module)
 
         for d in set(definitions):
             if isinstance(d, pr.Module):
-                names.append(api_classes.Usage(d, d))
+                names.append(api_classes.Usage(self._evaluator, d, d))
             elif isinstance(d, er.Instance):
                 # Instances can be ignored, because they are being created by
                 # ``__getattr__``.
                 pass
             else:
-                names.append(api_classes.Usage(d.names[-1], d))
+                names.append(api_classes.Usage(self._evaluator, d.names[-1], d))
 
         settings.dynamic_flow_information = temp
         return self._sorted_defs(set(names))
@@ -674,7 +674,7 @@ def defined_names(source, path=None, encoding='utf-8'):
         modules.source_to_unicode(source, encoding),
         module_path=path,
     )
-    return api_classes._defined_names(parser.module)
+    return api_classes._defined_names(Evaluator(), parser.module)
 
 
 def preload_module(*modules):
@@ -703,7 +703,7 @@ def set_debug_function(func_cb=debug.print_to_stdout, warnings=True,
 
 
 # TODO move to a better place.
-def usages(definitions, search_name, mods):
+def usages(evaluator, definitions, search_name, mods):
     def compare_array(definitions):
         """ `definitions` are being compared by module/start_pos, because
         sometimes the id's of the objects change (e.g. executions).
@@ -724,14 +724,14 @@ def usages(definitions, search_name, mods):
                 follow.append(call_path[:i + 1])
 
         for f in follow:
-            follow_res, search = evaluate.goto(call.parent, f)
+            follow_res, search = evaluator.goto(call.parent, f)
             follow_res = usages_add_import_modules(follow_res, search)
 
             compare_follow_res = compare_array(follow_res)
             # compare to see if they match
             if any(r in compare_definitions for r in compare_follow_res):
                 scope = call.parent
-                result.append(api_classes.Usage(search, scope))
+                result.append(api_classes.Usage(evaluator, search, scope))
 
         return result
 
@@ -741,7 +741,7 @@ def usages(definitions, search_name, mods):
     compare_definitions = compare_array(definitions)
     mods |= set([d.get_parent_until() for d in definitions])
     names = []
-    for m in get_directory_modules_for_name(mods, search_name):
+    for m in dynamic.get_directory_modules_for_name(mods, search_name):
         try:
             stmts = m.used_names[search_name]
         except KeyError:
@@ -757,26 +757,24 @@ def usages(definitions, search_name, mods):
                             imps.append((count, name_part))
 
                 for used_count, name_part in imps:
-                    i = imports.ImportPath(_evaluator, stmt, kill_count=count - used_count,
+                    i = imports.ImportPath(evaluator, stmt, kill_count=count - used_count,
                                            direct_resolve=True)
                     f = i.follow(is_goto=True)
                     if set(f) & set(definitions):
-                        names.append(api_classes.Usage(name_part, stmt))
+                        names.append(api_classes.Usage(evaluator, name_part, stmt))
             else:
-                for call in _scan_statement(stmt, search_name,
-                                            assignment_details=True):
+                for call in dynamic._scan_statement(stmt, search_name,
+                                                    assignment_details=True):
                     names += check_call(call)
     return names
 
 
-def usages_add_import_modules(definitions, search_name):
+def usages_add_import_modules(evaluator, definitions, search_name):
     """ Adds the modules of the imports """
     new = set()
     for d in definitions:
         if isinstance(d.parent, pr.Import):
-            s = imports.ImportPath(_evaluator, d.parent, direct_resolve=True)
+            s = imports.ImportPath(evaluator, d.parent, direct_resolve=True)
             with common.ignored(IndexError):
                 new.add(s.follow(is_goto=True)[0])
     return set(definitions) | new
-
-
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index b08f5ef7..53f75a9c 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -65,7 +65,8 @@ class BaseDefinition(object):
         '_sre.SRE_Pattern': 're.RegexObject',
     }.items())
 
-    def __init__(self, definition, start_pos):
+    def __init__(self, evaluator, definition, start_pos):
+        self._evaluator = evaluator
         self._start_pos = start_pos
         self._definition = definition
         """
@@ -303,8 +304,8 @@ class Completion(BaseDefinition):
     `Completion` objects are returned from :meth:`api.Script.completions`. They
     provide additional information about a completion.
     """
-    def __init__(self, name, needs_dot, like_name_length, base):
-        super(Completion, self).__init__(name.parent, name.start_pos)
+    def __init__(self, evaluator, name, needs_dot, like_name_length, base):
+        super(Completion, self).__init__(evaluator, name.parent, name.start_pos)
 
         self._name = name
         self._needs_dot = needs_dot
@@ -407,7 +408,7 @@ class Completion(BaseDefinition):
         """
         if self._followed_definitions is None:
             if self._definition.isinstance(pr.Statement):
-                defs = evaluate.follow_statement(self._definition)
+                defs = self._evaluator.follow_statement(self._definition)
             elif self._definition.isinstance(pr.Import):
                 defs = imports.strip_imports(self._evaluator, [self._definition])
             else:
@@ -428,8 +429,8 @@ class Definition(BaseDefinition):
     *Definition* objects are returned from :meth:`api.Script.goto_assignments`
     or :meth:`api.Script.goto_definitions`.
     """
-    def __init__(self, definition):
-        super(Definition, self).__init__(definition, definition.start_pos)
+    def __init__(self, evaluator, definition):
+        super(Definition, self).__init__(evaluator, definition, definition.start_pos)
 
     @property
     def name(self):
@@ -546,26 +547,26 @@ class Definition(BaseDefinition):
             d = d.var
         if isinstance(d, pr.Name):
             d = d.parent
-        return _defined_names(d)
+        return _defined_names(self._evaluator, d)
 
 
-def _defined_names(scope):
+def _defined_names(evaluator, scope):
     """
     List sub-definitions (e.g., methods in class).
 
     :type scope: Scope
     :rtype: list of Definition
     """
-    pair = next(evaluate.get_names_of_scope(
+    pair = next(evaluator.get_names_of_scope(
         scope, star_search=False, include_builtin=False), None)
     names = pair[1] if pair else []
-    return [Definition(d) for d in sorted(names, key=lambda s: s.start_pos)]
+    return [Definition(evaluator, d) for d in sorted(names, key=lambda s: s.start_pos)]
 
 
 class Usage(BaseDefinition):
     """TODO: document this"""
-    def __init__(self, name_part, scope):
-        super(Usage, self).__init__(scope, name_part.start_pos)
+    def __init__(self, evaluator, name_part, scope):
+        super(Usage, self).__init__(evaluator, scope, name_part.start_pos)
         self.text = unicode(name_part)
         self.end_pos = name_part.end_pos
 
diff --git a/test/test_builtin.py b/test/test_builtin.py
index 858792d4..b9513c30 100644
--- a/test/test_builtin.py
+++ b/test/test_builtin.py
@@ -1,4 +1,4 @@
-from jedi import builtin
+from jedi.evaluate import builtin
 
 
 def test_parse_function_doc_illegal_docstr():

From 8f564a301fa60a6ba20da894b3130a1bba3b8bf8 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Thu, 26 Dec 2013 02:10:30 +0100
Subject: [PATCH 33/42] clean up caches clearing

---
 jedi/api.py              | 12 +++---------
 jedi/api_classes.py      | 11 +++--------
 jedi/evaluate/imports.py |  5 -----
 test/test_api_classes.py |  5 +++--
 4 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/jedi/api.py b/jedi/api.py
index a18cc745..a0ff5b9a 100644
--- a/jedi/api.py
+++ b/jedi/api.py
@@ -82,7 +82,7 @@ class Script(object):
         if not (0 <= self._column <= line_len):
             raise ValueError('`column` parameter is not in a valid range.')
 
-        #api_classes._clear_caches()  # TODO REMOVE
+        api_classes.clear_caches()
         debug.reset_time()
         self.source = modules.source_to_unicode(source, encoding)
         self._pos = self._line, self._column
@@ -111,7 +111,6 @@ class Script(object):
         """ lazy parser."""
         return self._module.parser
 
-    #@api_classes._clear_caches_after_call
     def completions(self):
         """
         Return :class:`api_classes.Completion` objects. Those objects contain
@@ -319,7 +318,6 @@ class Script(object):
         sig = self.call_signatures()
         return sig[0] if sig else None
 
-    #@api_classes._clear_caches_after_call
     def goto_definitions(self):
         """
         Return the definitions of a the path under the cursor.  goto function!
@@ -383,7 +381,6 @@ class Script(object):
                  if s is not imports.ImportPath.GlobalNamespace])
         return self._sorted_defs(d)
 
-    #@api_classes._clear_caches_after_call
     def goto_assignments(self):
         """
         Return the first definition found. Imports and statements aren't
@@ -453,7 +450,6 @@ class Script(object):
                     definitions = [user_stmt]
         return definitions, search_name
 
-    #@api_classes._clear_caches_after_call
     def usages(self, additional_module_paths=()):
         """
         Return :class:`api_classes.Usage` objects, which contain all
@@ -477,8 +473,7 @@ class Script(object):
                                if unicode(v.names[-1]) == search_name]
         if not isinstance(user_stmt, pr.Import):
             # import case is looked at with add_import_name option
-            definitions = dynamic.usages_add_import_modules(definitions,
-                                                            search_name)
+            definitions = usages_add_import_modules(self._evaluator, definitions, search_name)
 
         module = set([d.get_parent_until() for d in definitions])
         module.add(self._parser.module)
@@ -497,7 +492,6 @@ class Script(object):
         settings.dynamic_flow_information = temp
         return self._sorted_defs(set(names))
 
-    #@api_classes._clear_caches_after_call
     def call_signatures(self):
         """
         Return the function object of the call you're currently in.
@@ -725,7 +719,7 @@ def usages(evaluator, definitions, search_name, mods):
 
         for f in follow:
             follow_res, search = evaluator.goto(call.parent, f)
-            follow_res = usages_add_import_modules(follow_res, search)
+            follow_res = usages_add_import_modules(evaluator, follow_res, search)
 
             compare_follow_res = compare_array(follow_res)
             # compare to see if they match
diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index 53f75a9c..facf40db 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -17,18 +17,13 @@ from jedi import keywords
 from jedi.evaluate import dynamic
 
 
-def _clear_caches():
+def clear_caches():
     """
     Clear all caches of this and related modules. The only cache that will not
     be deleted is the module cache.
     """
     cache.clear_caches()
     dynamic.search_param_cache.clear()
-    recursion.ExecutionRecursionDecorator.reset()
-
-    evaluate.follow_statement.reset()
-
-    imports.imports_processed = 0
 
 
 def _clear_caches_after_call(func):
@@ -38,7 +33,7 @@ def _clear_caches_after_call(func):
     @functools.wraps(func)
     def wrapper(*args, **kwds):
         result = func(*args, **kwds)
-        _clear_caches()
+        clear_caches()
         return result
     return wrapper
 
@@ -416,7 +411,7 @@ class Completion(BaseDefinition):
 
             self._followed_definitions = \
                 [BaseDefinition(d, d.start_pos) for d in defs]
-            _clear_caches()
+            clear_caches()
 
         return self._followed_definitions
 
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index aa6637fa..45a58bc0 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -26,9 +26,6 @@ from jedi.parser import representation as pr
 from jedi import cache
 from jedi.evaluate import builtin
 
-# for debugging purposes only
-imports_processed = 0
-
 
 class ModuleNotFound(Exception):
     pass
@@ -304,8 +301,6 @@ class ImportPath(pr.Base):
             elif self._is_relative_import():
                 path = self._get_relative_path()
 
-            global imports_processed
-            imports_processed += 1
             if path is not None:
                 importing = find_module(string, [path])
             else:
diff --git a/test/test_api_classes.py b/test/test_api_classes.py
index 5a66c330..6933a1a8 100644
--- a/test/test_api_classes.py
+++ b/test/test_api_classes.py
@@ -11,9 +11,9 @@ import jedi
 
 def test_is_keyword():
     results = Script('import ', 1, 1, None).goto_definitions()
-    assert len(results) == 1 and results[0].is_keyword == True
+    assert len(results) == 1 and results[0].is_keyword is True
     results = Script('str', 1, 1, None).goto_definitions()
-    assert len(results) == 1 and results[0].is_keyword == False
+    assert len(results) == 1 and results[0].is_keyword is False
 
 def make_definitions():
     """
@@ -71,6 +71,7 @@ def test_function_call_signature_in_doc():
     doc = defs[0].doc
     assert "f(x, y = 1, z = 'a')" in doc
 
+
 def test_class_call_signature():
     defs = Script("""
     class Foo:

From 84c2be9f5860de6d13fa4c04b155cb4bc7df7a91 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Thu, 26 Dec 2013 02:31:18 +0100
Subject: [PATCH 34/42] remove old way of using a separate decorator for search
 param memoization, use the default one

---
 jedi/api_classes.py      |  2 --
 jedi/evaluate/dynamic.py | 23 +++--------------------
 2 files changed, 3 insertions(+), 22 deletions(-)

diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index facf40db..c87225d9 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -14,7 +14,6 @@ from jedi import cache
 from jedi.evaluate import representation as er
 from jedi.evaluate import imports
 from jedi import keywords
-from jedi.evaluate import dynamic
 
 
 def clear_caches():
@@ -23,7 +22,6 @@ def clear_caches():
     be deleted is the module cache.
     """
     cache.clear_caches()
-    dynamic.search_param_cache.clear()
 
 
 def _clear_caches_after_call(func):
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index edaa1edb..502bcdeb 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -64,7 +64,6 @@ from jedi.evaluate.cache import memoize_default
 # This is something like the sys.path, but only for searching params. It means
 # that this is the order in which Jedi searches params.
 search_param_modules = ['.']
-search_param_cache = {}
 
 
 def get_directory_modules_for_name(mods, name):
@@ -110,22 +109,6 @@ def get_directory_modules_for_name(mods, name):
                 yield c
 
 
-def _search_param_memoize(func):
-    """
-    Is only good for search params memoize, respectively the closure,
-    because it just caches the input, not the func, like normal memoize does.
-    """
-    def wrapper(*args, **kwargs):
-        key = (args, frozenset(kwargs.items()))
-        if key in search_param_cache:
-            return search_param_cache[key]
-        else:
-            rv = func(*args, **kwargs)
-            search_param_cache[key] = rv
-            return rv
-    return wrapper
-
-
 class ParamListener(object):
     """
     This listener is used to get the params for a function.
@@ -158,8 +141,8 @@ def search_params(evaluator, param):
         """
         Returns the values of a param, or an empty array.
         """
-        @_search_param_memoize
-        def get_posibilities(module, func_name):
+        @memoize_default([], evaluator_is_first_arg=True)
+        def get_posibilities(evaluator, module, func_name):
             try:
                 possible_stmts = module.used_names[func_name]
             except KeyError:
@@ -209,7 +192,7 @@ def search_params(evaluator, param):
             return listener.param_possibilities
 
         result = []
-        for params in get_posibilities(module, func_name):
+        for params in get_posibilities(evaluator, module, func_name):
             for p in params:
                 if str(p) == param_name:
                     result += evaluator.follow_statement(p.parent)

From dd7d7ceb7e18b99f7592c9742658990bac578526 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Thu, 26 Dec 2013 12:20:29 +0100
Subject: [PATCH 35/42] make some parser caches private

---
 jedi/cache.py | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/jedi/cache.py b/jedi/cache.py
index 37f7a961..77436f38 100644
--- a/jedi/cache.py
+++ b/jedi/cache.py
@@ -31,9 +31,9 @@ from jedi import settings
 from jedi import common
 from jedi import debug
 
-time_caches = []
+_time_caches = []
 
-star_import_cache = {}
+_star_import_cache = {}
 
 # for fast_parser, should not be deleted
 parser_cache = {}
@@ -54,15 +54,15 @@ def clear_caches(delete_all=False):
     :param delete_all: Deletes also the cache that is normally not deleted,
         like parser cache, which is important for faster parsing.
     """
-    global time_caches
+    global _time_caches
 
     if delete_all:
-        time_caches = []
-        star_import_cache.clear()
+        _time_caches = []
+        _star_import_cache.clear()
         parser_cache.clear()
     else:
         # normally just kill the expired entries, not all
-        for tc in time_caches:
+        for tc in _time_caches:
             # check time_cache for expired entries
             for key, (t, value) in list(tc.items()):
                 if t < time.time():
@@ -78,7 +78,7 @@ def time_cache(time_add_setting):
     """
     def _temp(key_func):
         dct = {}
-        time_caches.append(dct)
+        _time_caches.append(dct)
 
         def wrapper(optional_callable, *args, **kwargs):
             key = key_func(*args, **kwargs)
@@ -105,13 +105,13 @@ def cache_call_signatures(stmt):
 def cache_star_import(func):
     def wrapper(evaluator, scope, *args, **kwargs):
         with common.ignored(KeyError):
-            mods = star_import_cache[scope]
+            mods = _star_import_cache[scope]
             if mods[0] + settings.star_import_cache_validity > time.time():
                 return mods[1]
         # cache is too old and therefore invalid or not available
         invalidate_star_import_cache(scope)
         mods = func(evaluator, scope, *args, **kwargs)
-        star_import_cache[scope] = time.time(), mods
+        _star_import_cache[scope] = time.time(), mods
 
         return mods
     return wrapper
@@ -120,9 +120,9 @@ def cache_star_import(func):
 def invalidate_star_import_cache(module, only_main=False):
     """ Important if some new modules are being reparsed """
     with common.ignored(KeyError):
-        t, mods = star_import_cache[module]
+        t, mods = _star_import_cache[module]
 
-        del star_import_cache[module]
+        del _star_import_cache[module]
 
         for m in mods:
             invalidate_star_import_cache(m, only_main=True)
@@ -130,7 +130,7 @@ def invalidate_star_import_cache(module, only_main=False):
     if not only_main:
         # We need a list here because otherwise the list is being changed
         # during the iteration in py3k: iteritems -> items.
-        for key, (t, mods) in list(star_import_cache.items()):
+        for key, (t, mods) in list(_star_import_cache.items()):
             if module in mods:
                 invalidate_star_import_cache(key)
 
@@ -246,7 +246,7 @@ class _ModulePickling(object):
             else:
                 # 0 means version is not defined (= always delete cache):
                 if data.get('version', 0) != self.version:
-                    self.delete_cache()
+                    self.clear_cache()
                     self.__index = {}
                 else:
                     self.__index = data['index']
@@ -265,7 +265,7 @@ class _ModulePickling(object):
             json.dump(data, f)
         self.__index = None
 
-    def delete_cache(self):
+    def clear_cache(self):
         shutil.rmtree(self._cache_directory())
 
     def _get_hashed_path(self, path):

From ff983f70bcd4593410b79a362e8913a3a63cae28 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Thu, 26 Dec 2013 18:01:54 +0100
Subject: [PATCH 36/42] fix execution recursion decorators

---
 jedi/evaluate/__init__.py       |  1 +
 jedi/evaluate/recursion.py      | 38 +++++++++++++++++++--------------
 jedi/evaluate/representation.py |  2 +-
 jedi/parser/fast.py             | 11 +++++-----
 4 files changed, 29 insertions(+), 23 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 9e75ea8e..160306ec 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -119,6 +119,7 @@ class Evaluator(object):
     def __init__(self):
         self.memoize_cache = {}  # for memoize decorators
         self.recursion_detector = recursion.RecursionDetector()
+        self.execution_recursion_detector = recursion.ExecutionRecursionDetector()
 
     def get_names_of_scope(self, scope, position=None, star_search=True,
                            include_builtin=True):
diff --git a/jedi/evaluate/recursion.py b/jedi/evaluate/recursion.py
index 566fd23c..a0bde9f2 100644
--- a/jedi/evaluate/recursion.py
+++ b/jedi/evaluate/recursion.py
@@ -96,14 +96,29 @@ class _RecursionNode(object):
             and not self.is_ignored and not other.is_ignored
 
 
-class ExecutionRecursionDecorator(object):
+def execution_recursion_decorator(func):
+    def run(execution, evaluate_generator=False):
+        detector = execution._evaluator.execution_recursion_detector
+        if detector.push_execution(execution, evaluate_generator):
+            result = []
+        else:
+            result = func(execution, evaluate_generator)
+        detector.pop_execution()
+        return result
+
+    return run
+
+
+class ExecutionRecursionDetector(object):
     """
     Catches recursions of executions.
     It is designed like a Singelton. Only one instance should exist.
     """
-    def __init__(self, func):
-        self.func = func
-        self.reset()
+    def __init__(self):
+        self.recursion_level = 0
+        self.parent_execution_funcs = []
+        self.execution_funcs = set()
+        self.execution_count = 0
 
     def __call__(self, execution, evaluate_generator=False):
         debug.dbg('Execution recursions: %s' % execution, self.recursion_level,
@@ -112,16 +127,14 @@ class ExecutionRecursionDecorator(object):
             result = []
         else:
             result = self.func(execution, evaluate_generator)
-        self.cleanup()
+        self.pop_execution()
         return result
 
-    @classmethod
-    def cleanup(cls):
+    def pop_execution(cls):
         cls.parent_execution_funcs.pop()
         cls.recursion_level -= 1
 
-    @classmethod
-    def check_recursion(cls, execution, evaluate_generator):
+    def push_execution(cls, execution, evaluate_generator):
         in_par_execution_funcs = execution.base in cls.parent_execution_funcs
         in_execution_funcs = execution.base in cls.execution_funcs
         cls.recursion_level += 1
@@ -147,10 +160,3 @@ class ExecutionRecursionDecorator(object):
         if cls.execution_count > settings.max_executions_without_builtins:
             return True
         return False
-
-    @classmethod
-    def reset(cls):
-        cls.recursion_level = 0
-        cls.parent_execution_funcs = []
-        cls.execution_funcs = set()
-        cls.execution_count = 0
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 1ff0f4f9..9015df66 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -429,7 +429,7 @@ class Execution(Executable):
         return base
 
     @memoize_default(default=())
-    @recursion.ExecutionRecursionDecorator
+    @recursion.execution_recursion_decorator
     def get_return_types(self, evaluate_generator=False):
         """ Get the return types of a function. """
         base = self._decorated
diff --git a/jedi/parser/fast.py b/jedi/parser/fast.py
index 45c97cfb..a2a23370 100644
--- a/jedi/parser/fast.py
+++ b/jedi/parser/fast.py
@@ -226,7 +226,6 @@ class FastParser(use_metaclass(CachedFastParser)):
         self.user_position = user_position
         self.reset_caches()
 
-
         try:
             self._parse(code)
         except:
@@ -372,8 +371,8 @@ class FastParser(use_metaclass(CachedFastParser)):
                     else:
                         self.current_node = self.current_node.add_node(node)
 
-                if self.current_node.parent and (isinstance(p.user_scope,
-                                    pr.SubModule) or p.user_scope is None) \
+                if self.current_node.parent and (isinstance(p.user_scope, pr.SubModule)
+                                                 or p.user_scope is None) \
                         and self.user_position \
                         and p.start_pos <= self.user_position < p.end_pos:
                     p.user_scope = self.current_node.parent.content_scope
@@ -407,9 +406,9 @@ class FastParser(use_metaclass(CachedFastParser)):
                 raise ValueError()
         except ValueError:
             p = Parser(parser_code, self.module_path,
-                               self.user_position, offset=(line_offset, 0),
-                               is_fast_parser=True, top_module=self.module,
-                               no_docstr=no_docstr)
+                       self.user_position, offset=(line_offset, 0),
+                       is_fast_parser=True, top_module=self.module,
+                       no_docstr=no_docstr)
             p.module.parent = self.module
         else:
             if nodes[index] != self.current_node:

From c862afb96768dd550ce514bdd4224d7080d278ba Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 01:27:07 +0100
Subject: [PATCH 37/42] fix a few nasty bugs

---
 jedi/evaluate/dynamic.py        | 2 +-
 jedi/evaluate/representation.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index 502bcdeb..dc1c43f4 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -492,5 +492,5 @@ def _check_isinstance_type(evaluator, stmt, search_name):
         else:
             result.append(c)
     for i, c in enumerate(result):
-        result[i] = er.Instance(c)
+        result[i] = er.Instance(evaluator, c)
     return result
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 9015df66..432f7395 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -196,6 +196,7 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
     variable (e.g. self.variable or class methods).
     """
     def __init__(self, evaluator, instance, var, is_class_var=False):
+        self._evaluator = evaluator
         if isinstance(var, pr.Function):
             var = Function(evaluator, var)
         elif isinstance(var, pr.Class):

From 40bd118acb49cbafa479c587427589bd6c4ba3fd Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 01:30:22 +0100
Subject: [PATCH 38/42] fix sys path tests

---
 test/completion/sys_path.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/completion/sys_path.py b/test/completion/sys_path.py
index 3d894487..ebaccc2c 100644
--- a/test/completion/sys_path.py
+++ b/test/completion/sys_path.py
@@ -12,11 +12,11 @@ sys.path.append(sys.path[1] + '/thirdparty')
 # syntax err
 sys.path.append('a' +* '/thirdparty')
 
-#? ['evaluate', 'evaluate_representation']
+#? ['evaluate']
 import evaluate
 
-#? ['goto']
-evaluate.goto
+#? ['Evaluator']
+evaluate.Evaluator
 
 #? ['jedi_']
 import jedi_

From c290afbb1a5c901ac3fa6876531a073a666d1961 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 01:34:23 +0100
Subject: [PATCH 39/42] increase pickling version and change mixin path for
 builtins

---
 jedi/cache.py            | 2 +-
 jedi/evaluate/builtin.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/jedi/cache.py b/jedi/cache.py
index 77436f38..51a5807a 100644
--- a/jedi/cache.py
+++ b/jedi/cache.py
@@ -174,7 +174,7 @@ def save_module(path, name, parser, pickling=True):
 
 class _ModulePickling(object):
 
-    version = 5
+    version = 6
     """
     Version number (integer) for file system cache.
 
diff --git a/jedi/evaluate/builtin.py b/jedi/evaluate/builtin.py
index a0bc7e18..5270c5cd 100644
--- a/jedi/evaluate/builtin.py
+++ b/jedi/evaluate/builtin.py
@@ -165,8 +165,8 @@ class BuiltinModule(modules.CachedModule):
 
             if name == '__builtin__' and not is_py3k:
                 name = 'builtins'
-            path = os.path.dirname(os.path.abspath(__file__))
-            with open(os.path.sep.join([path, 'mixin', name]) + '.pym') as f:
+            path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            with open(os.path.join(path, 'mixin', name) + '.pym') as f:
                 s = f.read()
         except IOError:
             return {}

From 4ec64a9763d18851f5a2e7cdd4b769bb25321149 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 01:35:33 +0100
Subject: [PATCH 40/42] move mixin to evaluate directory

---
 jedi/evaluate/builtin.py                 | 2 +-
 jedi/{ => evaluate}/mixin/_functools.pym | 0
 jedi/{ => evaluate}/mixin/_io.pym        | 0
 jedi/{ => evaluate}/mixin/_sqlite3.pym   | 0
 jedi/{ => evaluate}/mixin/_sre.pym       | 0
 jedi/{ => evaluate}/mixin/_weakref.pym   | 0
 jedi/{ => evaluate}/mixin/builtins.pym   | 0
 jedi/{ => evaluate}/mixin/datetime.pym   | 0
 jedi/{ => evaluate}/mixin/posix.pym      | 0
 setup.py                                 | 2 +-
 10 files changed, 2 insertions(+), 2 deletions(-)
 rename jedi/{ => evaluate}/mixin/_functools.pym (100%)
 rename jedi/{ => evaluate}/mixin/_io.pym (100%)
 rename jedi/{ => evaluate}/mixin/_sqlite3.pym (100%)
 rename jedi/{ => evaluate}/mixin/_sre.pym (100%)
 rename jedi/{ => evaluate}/mixin/_weakref.pym (100%)
 rename jedi/{ => evaluate}/mixin/builtins.pym (100%)
 rename jedi/{ => evaluate}/mixin/datetime.pym (100%)
 rename jedi/{ => evaluate}/mixin/posix.pym (100%)

diff --git a/jedi/evaluate/builtin.py b/jedi/evaluate/builtin.py
index 5270c5cd..9a57a854 100644
--- a/jedi/evaluate/builtin.py
+++ b/jedi/evaluate/builtin.py
@@ -165,7 +165,7 @@ class BuiltinModule(modules.CachedModule):
 
             if name == '__builtin__' and not is_py3k:
                 name = 'builtins'
-            path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            path = os.path.dirname(os.path.abspath(__file__))
             with open(os.path.join(path, 'mixin', name) + '.pym') as f:
                 s = f.read()
         except IOError:
diff --git a/jedi/mixin/_functools.pym b/jedi/evaluate/mixin/_functools.pym
similarity index 100%
rename from jedi/mixin/_functools.pym
rename to jedi/evaluate/mixin/_functools.pym
diff --git a/jedi/mixin/_io.pym b/jedi/evaluate/mixin/_io.pym
similarity index 100%
rename from jedi/mixin/_io.pym
rename to jedi/evaluate/mixin/_io.pym
diff --git a/jedi/mixin/_sqlite3.pym b/jedi/evaluate/mixin/_sqlite3.pym
similarity index 100%
rename from jedi/mixin/_sqlite3.pym
rename to jedi/evaluate/mixin/_sqlite3.pym
diff --git a/jedi/mixin/_sre.pym b/jedi/evaluate/mixin/_sre.pym
similarity index 100%
rename from jedi/mixin/_sre.pym
rename to jedi/evaluate/mixin/_sre.pym
diff --git a/jedi/mixin/_weakref.pym b/jedi/evaluate/mixin/_weakref.pym
similarity index 100%
rename from jedi/mixin/_weakref.pym
rename to jedi/evaluate/mixin/_weakref.pym
diff --git a/jedi/mixin/builtins.pym b/jedi/evaluate/mixin/builtins.pym
similarity index 100%
rename from jedi/mixin/builtins.pym
rename to jedi/evaluate/mixin/builtins.pym
diff --git a/jedi/mixin/datetime.pym b/jedi/evaluate/mixin/datetime.pym
similarity index 100%
rename from jedi/mixin/datetime.pym
rename to jedi/evaluate/mixin/datetime.pym
diff --git a/jedi/mixin/posix.pym b/jedi/evaluate/mixin/posix.pym
similarity index 100%
rename from jedi/mixin/posix.pym
rename to jedi/evaluate/mixin/posix.pym
diff --git a/setup.py b/setup.py
index e01ea656..f8b2172b 100755
--- a/setup.py
+++ b/setup.py
@@ -27,7 +27,7 @@ setup(name='jedi',
       keywords='python completion refactoring vim',
       long_description=readme,
       packages=['jedi', 'jedi.parser', 'jedi.evaluate'],
-      package_data={'jedi': ['mixin/*.pym']},
+      package_data={'jedi': ['evlaluate/evaluate/mixin/*.pym']},
       platforms=['any'],
       classifiers=[
           'Development Status :: 4 - Beta',

From 08fba1e191d6e8ca177861d8d36b050577b2042a Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 02:28:01 +0100
Subject: [PATCH 41/42] fix last remaining issues with tests

---
 jedi/api_classes.py     | 2 +-
 test/test_cache.py      | 6 +++---
 test/test_full_name.py  | 3 ++-
 test/test_regression.py | 9 +++++----
 4 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/jedi/api_classes.py b/jedi/api_classes.py
index c87225d9..49c41320 100644
--- a/jedi/api_classes.py
+++ b/jedi/api_classes.py
@@ -408,7 +408,7 @@ class Completion(BaseDefinition):
                 return [self]
 
             self._followed_definitions = \
-                [BaseDefinition(d, d.start_pos) for d in defs]
+                [BaseDefinition(self._evaluator, d, d.start_pos) for d in defs]
             clear_caches()
 
         return self._followed_definitions
diff --git a/test/test_cache.py b/test/test_cache.py
index 463fb8a1..aa8a3725 100644
--- a/test/test_cache.py
+++ b/test/test_cache.py
@@ -66,7 +66,7 @@ def test_star_import_cache_duration():
     old, jedi.settings.star_import_cache_validity = \
             jedi.settings.star_import_cache_validity, new
 
-    cache.star_import_cache = {}  # first empty...
+    cache._star_import_cache = {}  # first empty...
     # path needs to be not-None (otherwise caching effects are not visible)
     jedi.Script('', 1, 0, '').completions()
     time.sleep(2 * new)
@@ -74,6 +74,6 @@ def test_star_import_cache_duration():
 
     # reset values
     jedi.settings.star_import_cache_validity = old
-    length = len(cache.star_import_cache)
-    cache.star_import_cache = {}
+    length = len(cache._star_import_cache)
+    cache._star_import_cache = {}
     assert length == 1
diff --git a/test/test_full_name.py b/test/test_full_name.py
index 5378a97a..a8c83637 100644
--- a/test/test_full_name.py
+++ b/test/test_full_name.py
@@ -17,6 +17,7 @@ import textwrap
 
 import jedi
 from jedi import api_classes
+from jedi.evaluate import Evaluator
 from .helpers import TestCase
 
 
@@ -82,5 +83,5 @@ def test_keyword_full_name_should_be_none():
     # Using `from jedi.keywords import Keyword` here does NOT work
     # in Python 3.  This is due to the import hack jedi using.
     Keyword = api_classes.keywords.Keyword
-    d = api_classes.Definition(Keyword('(', (0, 0)))
+    d = api_classes.Definition(Evaluator(), Keyword('(', (0, 0)))
     assert d.full_name is None
diff --git a/test/test_regression.py b/test/test_regression.py
index c50998c8..035ca3d8 100644
--- a/test/test_regression.py
+++ b/test/test_regression.py
@@ -75,13 +75,14 @@ class TestRegression(TestCase):
 
     @cwd_at('jedi')
     def test_add_dynamic_mods(self):
-        api.settings.additional_dynamic_modules = ['dynamic.py']
+        fname = '__main__.py'
+        api.settings.additional_dynamic_modules = [fname]
         # Fictional module that defines a function.
-        src1 = "def ret(a): return a"
+        src1 = "def r(a): return a"
         # Other fictional modules in another place in the fs.
-        src2 = 'from .. import setup; setup.ret(1)'
+        src2 = 'from .. import setup; setup.r(1)'
         # .parser to load the module
-        api.modules.Module(os.path.abspath('dynamic.py'), src2).parser
+        api.modules.Module(os.path.abspath(fname), src2).parser
         result = Script(src1, path='../setup.py').goto_definitions()
         assert len(result) == 1
         assert result[0].description == 'class int'

From d40030c14ed996b6abb36443e55b797e11fb844a Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Fri, 27 Dec 2013 02:40:52 +0100
Subject: [PATCH 42/42] disable a test for py26.

---
 jedi/_compatibility.py          | 1 +
 test/test_integration_import.py | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/jedi/_compatibility.py b/jedi/_compatibility.py
index 79d43737..47d2b3e7 100644
--- a/jedi/_compatibility.py
+++ b/jedi/_compatibility.py
@@ -13,6 +13,7 @@ except ImportError:
 
 is_py3k = sys.hexversion >= 0x03000000
 is_py33 = sys.hexversion >= 0x03030000
+is_py26 = sys.hexversion < 0x02700000
 
 
 def find_module_py33(string, path=None):
diff --git a/test/test_integration_import.py b/test/test_integration_import.py
index 401b7945..4f869f90 100644
--- a/test/test_integration_import.py
+++ b/test/test_integration_import.py
@@ -7,6 +7,7 @@ import itertools
 
 from jedi import Script
 from .helpers import cwd_at
+from jedi._compatibility import is_py26
 
 
 def test_goto_definition_on_import():
@@ -21,7 +22,8 @@ def test_complete_on_empty_import():
     assert 10 < len(Script("from . import", 1, 5, '').completions()) < 30
     assert 10 < len(Script("from . import classes", 1, 5, '').completions()) < 30
     assert len(Script("import").completions()) == 0
-    assert len(Script("import import", path='').completions()) > 0
+    if not is_py26:
+        assert len(Script("import import", path='').completions()) > 0
 
     # 111
     assert Script("from datetime import").completions()[0].name == 'import'