Use a different function signature instead of a separate goto_stubs function

jedi/evaluate/__init__.py

@@ -85,7 +85,7 @@ from jedi.evaluate.context.iterable import CompForContext
 from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \
     eval_node, check_tuple_assignments
 from jedi.evaluate.gradual.conversion import try_stub_to_actual_names, \
-    try_stubs_to_actual_context_set
+    actual_to_stub_names, try_stubs_to_actual_context_set
 
 
 def _execute(context, arguments):
@@ -322,11 +322,6 @@ class Evaluator(object):
         return None
 
     def goto(self, context, name):
-        names = self._goto(context, name)
-        names = try_stub_to_actual_names(names, prefer_stub_to_compiled=True)
-        return names
-
-    def _goto(self, context, name):
         definition = name.get_definition(import_name_always=True)
         if definition is not None:
             type_ = definition.type

jedi/evaluate/compiled/context.py

@@ -263,6 +263,10 @@ class CompiledName(AbstractNameDefinition):
         self.parent_context = parent_context
         self.string_name = name
 
+    def _get_qualified_names(self):
+        parent_qualified_names = self.parent_context.get_qualified_names()
+        return parent_qualified_names + (self.string_name,)
+
     def __repr__(self):
         try:
             name = self.parent_context.name  # __name__ is not defined all the time

jedi/evaluate/gradual/conversion.py

@@ -104,8 +104,36 @@ def _load_stub_module(module):
     )
 
 
-def name_to_stub(name):
-    return ContextSet.from_sets(to_stub(c) for c in name.infer())
+@to_list
+def actual_to_stub_names(names, fallback_to_actual=False):
+    for name in names:
+        module = name.get_root_context()
+        if module.is_stub():
+            yield name
+            continue
+
+        name_list = name.get_qualified_names()
+        stubs = NO_CONTEXTS
+        if name_list is not None:
+            stub_module = _load_stub_module(module)
+            if stub_module is not None:
+                stubs = ContextSet({stub_module})
+                for name in name_list[:-1]:
+                    stubs = stubs.py__getattribute__(name)
+        if stubs and name_list:
+            new_names = stubs.py__getattribute__(name_list[-1], is_goto=True)
+            for new_name in new_names:
+                yield new_name
+            if new_names:
+                continue
+        elif stubs:
+            for c in stubs:
+                yield c.name
+            continue
+        if fallback_to_actual:
+            # This is the part where if we haven't found anything, just return
+            # the stub name.
+            yield name
 
 
 def to_stub(context):

jedi/evaluate/names.py

@@ -27,8 +27,18 @@ class AbstractNameDefinition(object):
         # name will always result on itself.
         return {self}
 
-    @abstractmethod
     def get_qualified_names(self, include_module_names=False):
+        qualified_names = self._get_qualified_names()
+        if qualified_names is None or not include_module_names:
+            return qualified_names
+
+        module_names = self.get_root_context().string_names
+        if module_names is None:
+            return None
+        return module_names + qualified_names
+
+    @abstractmethod
+    def _get_qualified_names(self):
         raise NotImplementedError
 
     def get_root_context(self):
@@ -56,21 +66,20 @@ class AbstractTreeName(AbstractNameDefinition):
     def get_qualified_names(self, include_module_names=False):
         import_node = search_ancestor(self.tree_name, 'import_name', 'import_from')
         if import_node is not None:
-            return tuple(n.value for n in import_node.get_path_for_name(self.tree_name))
+            if include_module_names:
+                return tuple(n.value for n in import_node.get_path_for_name(self.tree_name))
+            else:
+                return ()
+        return super(AbstractTreeName, self).get_qualified_names(include_module_names)
 
+    def _get_qualified_names(self):
         parent_names = self.parent_context.get_qualified_names()
         if parent_names is None:
             return None
-        parent_names += (self.tree_name.value,)
-        if include_module_names:
-            module_names = self.get_root_context().string_names
-            if module_names is None:
-                return None
-            return module_names + parent_names
-        return parent_names
+        return parent_names + (self.tree_name.value,)
 
-    def goto(self):
-        return self.parent_context.evaluator.goto(self.parent_context, self.tree_name)
+    def goto(self, **kwargs):
+        return self.parent_context.evaluator.goto(self.parent_context, self.tree_name, **kwargs)
 
     def is_import(self):
         imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
@@ -89,15 +98,8 @@ class ContextNameMixin(object):
     def infer(self):
         return ContextSet([self._context])
 
-    def get_qualified_names(self, include_module_names=False):
-        qualified_names = self._context.get_qualified_names()
-        if qualified_names is None or not include_module_names:
-            return qualified_names
-
-        module_names = self.get_root_context().string_names
-        if module_names is None:
-            return None
-        return module_names + qualified_names
+    def _get_qualified_names(self):
+        return self._context.get_qualified_names()
 
     def get_root_context(self):
         if self.parent_context is None:  # A module
@@ -115,8 +117,7 @@ class ContextName(ContextNameMixin, AbstractTreeName):
         self._context = context
 
     def goto(self):
-        from jedi.evaluate.gradual.conversion import try_stub_to_actual_names
-        return try_stub_to_actual_names([self._context.name])
+        return ContextSet([self._context.name])
 
 
 class TreeNameDefinition(AbstractTreeName):