Fix all gradual tests

jedi/api/__init__.py

@@ -40,7 +40,7 @@ from jedi.evaluate.base_context import ContextSet
 from jedi.evaluate.context.iterable import unpack_tuple_to_dict
 #from jedi.evaluate.gradual.typeshed import try_to_merge_with_stub
 from jedi.evaluate.gradual.stub_context import try_stubs_to_actual_context_set, \
-    try_stubs_to_actual_names
+    try_stub_to_actual_names
 from jedi.evaluate.gradual.utils import load_proper_stub_module
 
 # Jedi uses lots and lots of recursion. By setting this a little bit higher, we
@@ -308,7 +308,7 @@ class Script(object):
                 return isinstance(name, imports.SubModuleName)
 
         names = filter_follow_imports(names, check)
-        names = try_stubs_to_actual_names(names, prefer_stub_to_compiled=True)
+        names = try_stub_to_actual_names(names, prefer_stub_to_compiled=True)
 
         defs = [classes.Definition(self._evaluator, d) for d in set(names)]
         return helpers.sorted_definitions(defs)

jedi/evaluate/base_context.py

@@ -101,6 +101,10 @@ class HelperContextMixin(object):
             return class2.is_same_class(self)
         return self == class2
 
+    def is_stub(self):
+        # The root context knows if it's a stub or not.
+        return self.parent_context.is_stub()
+
 
 class Context(HelperContextMixin, BaseContext):
     """
@@ -154,9 +158,6 @@ class Context(HelperContextMixin, BaseContext):
     def is_module(self):
         return False
 
-    def is_stub(self):
-        return False
-
     def is_compiled(self):
         return False
 

jedi/evaluate/compiled/context.py

@@ -102,6 +102,9 @@ class CompiledObject(Context):
     def is_compiled(self):
         return True
 
+    def is_stub(self):
+        return False
+
     def py__doc__(self, include_call_signature=False):
         return self.access_handle.py__doc__()
 

jedi/evaluate/context/instance.py

@@ -393,12 +393,6 @@ class BoundMethod(FunctionMixin, ContextWrapper):
         if isinstance(self._wrapped_context, OverloadedFunctionContext):
             return self._wrapped_context.py__call__(self._get_arguments(arguments))
 
-        # This might not be the most beautiful way, but prefer stub_contexts
-        # and execute those if possible.
-        stub_context = self._wrapped_context.stub_context
-        if stub_context is not None:
-            return stub_context.py__call__(arguments)
-
         function_execution = self.get_function_execution(arguments)
         return function_execution.infer()
 

jedi/evaluate/context/module.py

@@ -93,6 +93,9 @@ class ModuleMixin(SubModuleDictMixin):
     def is_module(self):
         return True
 
+    def is_stub(self):
+        return False
+
     @property
     @evaluator_method_cache()
     def name(self):

jedi/evaluate/gradual/stub_context.py

@@ -298,6 +298,8 @@ def with_stub_context_if_possible(actual_context):
 
 
 def goto_with_stubs_if_possible(name):
+    return [name]
+    # XXX
     root = name.parent_context.get_root_context()
     stub = root.get_root_context().stub_context
     if stub is None:
@@ -323,7 +325,7 @@ def goto_non_stub(parent_context, tree_name):
     return contexts.py__getattribute__(tree_name, is_goto=True)
 
 
-def stub_to_actual_context_set(stub_context):
+def stub_to_actual_context_set(stub_context, ignore_compiled=False):
     qualified_names = stub_context.get_qualified_names()
     if qualified_names is None:
         return NO_CONTEXTS
@@ -335,6 +337,8 @@ def stub_to_actual_context_set(stub_context):
 
     assert isinstance(stub_module, StubOnlyModuleContext), stub_module
     non_stubs = stub_module.non_stub_context_set
+    if ignore_compiled:
+        non_stubs = non_stubs.filter(lambda c: not c.is_compiled())
     for name in qualified_names:
         non_stubs = non_stubs.py__getattribute__(name)
     return non_stubs
@@ -342,34 +346,47 @@ def stub_to_actual_context_set(stub_context):
 
 def try_stubs_to_actual_context_set(stub_contexts, prefer_stub_to_compiled=False):
     return ContextSet.from_sets(
-        stub_to_actual_context_set(stub_context) or ContextSet(stub_context)
+        stub_to_actual_context_set(stub_context, ignore_compiled=prefer_stub_to_compiled)
+        or ContextSet([stub_context])
         for stub_context in stub_contexts
     )
 
 
 @to_list
-def try_stubs_to_actual_names(names, prefer_stub_to_compiled=False):
+def try_stub_to_actual_names(names, prefer_stub_to_compiled=False):
     for name in names:
-        parent_context = name.parent_context
+        # Using the tree_name is better, if it's available, becuase no
+        # information is lost. If the name given is defineda as `foo: int` we
+        # would otherwise land on int, which is not what we want. We want foo
+        # from the non-stub module.
         if name.tree_name is None:
-            continue
-
-        if not parent_context.get_root_context().is_stub():
-            yield name
-            continue
-
-        contexts = stub_to_actual_context_set(parent_context)
-        if prefer_stub_to_compiled:
-            # We don't really care about
-            contexts = ContextSet([c for c in contexts if not c.is_compiled()])
-
-        new_names = contexts.py__getattribute__(name.tree_name, is_goto=True)
-
-        if new_names:
-            for n in new_names:
-                yield n
+            actual_contexts = ContextSet.from_sets(
+                stub_to_actual_context_set(c) for c in name.infer()
+            )
+            actual_contexts = actual_contexts.filter(lambda c: not c.is_compiled())
+            if actual_contexts:
+                for s in actual_contexts:
+                    yield s.name
+            else:
+                yield name
         else:
-            yield name
+            parent_context = name.parent_context
+            if not parent_context.is_stub():
+                yield name
+                continue
+
+            contexts = stub_to_actual_context_set(parent_context)
+            if prefer_stub_to_compiled:
+                # We don't really care about
+                contexts = contexts.filter(lambda c: not c.is_compiled())
+
+            new_names = contexts.py__getattribute__(name.tree_name, is_goto=True)
+
+            if new_names:
+                for n in new_names:
+                    yield n
+            else:
+                yield name
 
 
 def stubify(parent_context, context):