evaluator stuff for dynamic

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
+from jedi.evaluate import dynamic
-import dynamic
+from jedi import api_classes
 
 
 class NotFoundError(Exception):

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():

jedi/docstrings.py

@@ -32,8 +32,8 @@ DOCSTRING_RETURN_PATTERNS = [
 REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
 
 
-@memoize_default(None)
+@memoize_default(None, is_function=True)
-def follow_param(param):
+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 []
 
 

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 ('*', '**'):

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

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([])
+@memoize_default([], is_function=True)
-def search_params(param):
+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,
+                        s = evaluator.find_name(scope, func_name, position=pos,
-                                               search_global=not first,
+                                                search_global=not first,
-                                               resolve_decorator=False)
+                                                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)

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):