A lot of small improvements.

jedi/evaluate/compiled/__init__.py

@@ -10,9 +10,10 @@ from functools import partial
 from jedi._compatibility import builtins as _builtins, unicode
 from jedi import debug
 from jedi.cache import underscore_memoization, memoize_method
-from jedi.parser.tree import Param, Base, Operator
+from jedi.parser.tree import Param, Operator
 from jedi.evaluate.helpers import FakeName
 from jedi.evaluate.filters import AbstractFilter, AbstractNameDefinition
+from jedi.evaluate.context import Context
 from . import fake
 
 
@@ -36,22 +37,27 @@ class CheckAttribute(object):
         return partial(self.func, instance)
 
 
-class CompiledObject(Base):
+class CompiledObject(Context):
     # comply with the parser
     start_pos = 0, 0
     path = None  # modules have this attribute - set it to None.
     used_names = {}  # To be consistent with modules.
 
-    def __init__(self, evaluator, obj, parent=None):
+    def __init__(self, evaluator, obj, parent_context=None):
         self._evaluator = evaluator
         self.obj = obj
-        self.parent = parent
+        self.parent_context = parent_context
+
+    def get_root_node(self):
+        # To make things a bit easier with filters we add this method here.
+        return self.get_root_context()
 
     @CheckAttribute
     def py__call__(self, params):
         if inspect.isclass(self.obj):
             from jedi.evaluate.representation import Instance
-            return set([Instance(self._evaluator, self, params)])
+            return set([self])
+            return set([Instance(self._evaluator, self.parent_context, self, params)])
         else:
             return set(self._execute_function(params))
 
@@ -206,7 +212,7 @@ class CompiledObject(Base):
             name = self._get_class().__name__
         except AttributeError:
             name = repr(self.obj)
-        return FakeName(name, self)
+        return CompiledContextName(self, name)
 
     def _execute_function(self, params):
         if self.type != 'funcdef':
@@ -267,15 +273,21 @@ class CompiledName(AbstractNameDefinition):
             name = None
         return '<%s: (%s).%s>' % (type(self).__name__, name, self.string_name)
 
-    def is_definition(self):
-        return True
-
     @underscore_memoization
     def infer(self):
-        module = self._compiled_obj.get_parent_until()
+        module = self._compiled_obj.get_root_context()
         return [_create_from_name(self._evaluator, module, self._compiled_obj, self.string_name)]
 
 
+class CompiledContextName(AbstractNameDefinition):
+    def __init__(self, parent_context, name):
+        self.string_name = name
+        self.parent_context = parent_context
+
+    def infer(self):
+        return [self.parent_context]
+
+
 class LazyNamesDict(object):
     """
     A names_dict instance for compiled objects, resembles the parser.tree.

jedi/evaluate/compiled/fake.py

@@ -11,7 +11,6 @@ import types
 from jedi._compatibility import is_py3, builtins, unicode, is_py34
 from jedi.parser import ParserWithRecovery, load_grammar
 from jedi.parser import tree as pt
-from jedi.evaluate.helpers import FakeName
 
 modules = {}
 
@@ -69,14 +68,14 @@ def _load_faked_module(module):
         if module_name == 'builtins' and not is_py3:
             # There are two implementations of `open` for either python 2/3.
             # -> Rename the python2 version (`look at fake/builtins.pym`).
-            open_func = search_scope(module, 'open')
-            open_func.children[1] = FakeName('open_python3')
-            open_func = search_scope(module, 'open_python2')
-            open_func.children[1] = FakeName('open')
+            open_func = _search_scope(module, 'open')
+            open_func.children[1].value = 'open_python3'
+            open_func = _search_scope(module, 'open_python2')
+            open_func.children[1].value = 'open'
         return module
 
 
-def search_scope(scope, obj_name):
+def _search_scope(scope, obj_name):
     for s in scope.subscopes:
         if str(s.name) == obj_name:
             return s
@@ -120,7 +119,7 @@ def _faked(module, obj, name):
     # for methods.
     if name is None:
         if inspect.isbuiltin(obj):
-            return search_scope(faked_mod, obj.__name__), faked_mod
+            return _search_scope(faked_mod, obj.__name__), faked_mod
         elif not inspect.isclass(obj):
             # object is a method or descriptor
             try:
@@ -128,22 +127,22 @@ def _faked(module, obj, name):
             except AttributeError:
                 return None, None
             else:
-                cls = search_scope(faked_mod, objclass.__name__)
+                cls = _search_scope(faked_mod, objclass.__name__)
                 if cls is None:
                     return None, None
-                return search_scope(cls, obj.__name__), faked_mod
+                return _search_scope(cls, obj.__name__), faked_mod
     else:
         if obj == module:
-            return search_scope(faked_mod, name), faked_mod
+            return _search_scope(faked_mod, name), faked_mod
         else:
             try:
                 cls_name = obj.__name__
             except AttributeError:
                 return None, None
-            cls = search_scope(faked_mod, cls_name)
+            cls = _search_scope(faked_mod, cls_name)
             if cls is None:
                 return None, None
-            return search_scope(cls, name), faked_mod
+            return _search_scope(cls, name), faked_mod
     return None, None