Some analysis improvements.

jedi/api/__init__.py

@@ -13,7 +13,6 @@ import os
 import warnings
 import sys
 
-from jedi._compatibility import unicode
 from jedi.parser import load_grammar
 from jedi.parser import tree
 from jedi.parser.fast import FastParser
@@ -195,7 +194,7 @@ class Script(object):
             if leaf is None:
                 return []
 
-        context = self._evaluator.create_context(self._get_module(), leaf.parent)
+        context = self._evaluator.create_context(self._get_module(), leaf)
         definitions = helpers.evaluate_goto_definition(self._evaluator, context, leaf)
 
         names = [s.name for s in definitions]
@@ -328,11 +327,12 @@ class Script(object):
         self._evaluator.analysis_modules = [module_node]
         try:
             for node in module_node.nodes_to_execute():
+                context = self._get_module().create_context(node)
                 if node.type in ('funcdef', 'classdef'):
-                    if node.type == 'classdef':
-                        continue
-                        raise NotImplementedError
-                    er.Function(self._evaluator, node).get_decorated_func()
+                    # TODO This is stupid, should be private
+                    from jedi.evaluate.finder import _name_to_types
+                    # Resolve the decorators.
+                    _name_to_types(self._evaluator, context, node.children[1])
                 elif isinstance(node, tree.Import):
                     import_names = set(node.get_defined_names())
                     if node.is_nested():
@@ -340,12 +340,12 @@ class Script(object):
                     for n in import_names:
                         imports.ImportWrapper(context, n).follow()
                 elif node.type == 'expr_stmt':
-                    types = self._evaluator.eval_element(node)
+                    types = context.eval_node(node)
                     for testlist in node.children[:-1:2]:
                         # Iterate tuples.
                         unpack_tuple_to_dict(self._evaluator, types, testlist)
                 else:
-                    try_iter_content(self._evaluator.goto_definitions(node))
+                    try_iter_content(self._evaluator.goto_definitions(context, node))
                 self._evaluator.reset_recursion_limitations()
 
             ana = [a for a in self._evaluator.analysis if self.path == a.path]

jedi/api/classes.py

@@ -133,7 +133,7 @@ class BaseDefinition(object):
         >>> defs = sorted(defs, key=lambda d: d.line)
         >>> defs                           # doctest: +NORMALIZE_WHITESPACE
         [<Definition module keyword>, <Definition class C>,
-         <Definition class D>, <Definition def f>]
+         <Definition instance D>, <Definition def f>]
 
         Finally, here is what you can get from :attr:`type`:
 
@@ -489,7 +489,7 @@ class Completion(BaseDefinition):
         return '%s: %s%s' % (t, desc, line)
 
     def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self._name)
+        return '<%s: %s>' % (type(self).__name__, self._name.string_name)
 
     @memoize_method
     def _follow_statements_imports(self):
@@ -556,7 +556,7 @@ class Definition(BaseDefinition):
         """
         typ = self.type
         tree_name = self._name.tree_name
-        if typ in ('function', 'class', 'module') or tree_name is None:
+        if typ in ('function', 'class', 'module', 'instance') or tree_name is None:
             if typ == 'function':
                 # For the description we want a short and a pythonic way.
                 typ = 'def'
@@ -743,8 +743,8 @@ class CallSignature(Definition):
         return self._executable.get_parent_until()
 
     def __repr__(self):
-        return '<%s: %s index %s>' % (type(self).__name__, self._name,
-                                      self.index)
+        return '<%s: %s index %s>' % \
+            (type(self).__name__, self._name.string_name, self.index)
 
 
 class _Param(Definition):

jedi/api/usages.py

@@ -9,19 +9,31 @@ def usages(evaluator, definition_names, mods):
     """
     :param definitions: list of Name
     """
+    def resolve_names(definition_names):
+        for name in definition_names:
+            if name.api_type == 'module':
+                found = False
+                for context in name.infer():
+                    found = True
+                    yield context.name
+                if not found:
+                    yield name
+            else:
+                yield name
+
     def compare_array(definition_names):
         """ `definitions` are being compared by module/start_pos, because
         sometimes the id's of the objects change (e.g. executions).
         """
         return [
-            (d.get_root_context(), d.start_pos)
-            for d in definition_names
+            (name.get_root_context(), name.start_pos)
+            for name in resolve_names(definition_names)
         ]
 
     search_name = list(definition_names)[0].string_name
     compare_definitions = compare_array(definition_names)
     mods = mods | set([d.get_root_context() for d in definition_names])
-    definition_names = set(definition_names)
+    definition_names = set(resolve_names(definition_names))
     for m in imports.get_modules_containing_name(evaluator, mods, search_name):
         if isinstance(m, ModuleContext):
             for name_node in m.module_node.used_names.get(search_name, []):