Add a filter for global names.

jedi/evaluate/filters.py

@@ -6,14 +6,15 @@ from abc import abstractmethod
 
 from jedi.parser.tree import search_ancestor
 from jedi.evaluate import flow_analysis
+from jedi.common import to_list
 
 
 class AbstractFilter(object):
+    _until_position = None
+
     def __init__(self, origin_scope=None):
         self._origin_scope = origin_scope
 
-    _until_position = None
-
     def _filter(self, names):
         if self._until_position is not None:
             return [n for n in names if n.start_pos < self._until_position]
@@ -21,32 +22,46 @@ class AbstractFilter(object):
 
     @abstractmethod
     def get(self, name):
-        pass
+        raise NotImplementedError
 
     @abstractmethod
     def values(self):
-        pass
+        raise NotImplementedError
 
 
-class ParserTreeFilter(AbstractFilter):
-    def __init__(self, parser_scope, until_position=None, origin_scope=None):
-        super(ParserTreeFilter, self).__init__(origin_scope)
+class AbstractUsedNamesFilter(AbstractFilter):
+    def __init__(self, parser_scope, origin_scope=None):
+        super(AbstractUsedNamesFilter, self).__init__(origin_scope)
         self._parser_scope = parser_scope
         self._used_names = self._parser_scope.get_root_node().used_names
+
+    def get(self, name):
+        try:
+            names = self._used_names[str(name)]
+        except KeyError:
+            return []
+
+        return list(self._filter(names))
+
+    def values(self):
+        return self._filter(self._used_names.values())
+
+
+class ParserTreeFilter(AbstractUsedNamesFilter):
+    def __init__(self, evaluator, parser_scope, until_position=None, origin_scope=None):
+        super(ParserTreeFilter, self).__init__(parser_scope, origin_scope)
         self._until_position = until_position
-        self._origin_scope = origin_scope
+        self._evaluator = evaluator
 
     def _filter(self, names):
         names = super(ParserTreeFilter, self)._filter(names)
         names = [n for n in names if n.is_definition()]
         names = [n for n in names if n.parent.get_parent_scope() == self._parser_scope]
 
-        return list(self._check_flows(sorted(names, key=lambda name: name.start_pos)))
+        return list(self._check_flows(names))
 
     def _check_flows(self, names):
-        for name in names:
-            yield name
-            continue
+        for name in sorted(names, key=lambda name: name.start_pos, reverse=True):
             stmt = name.get_definition()
             name_scope = self._evaluator.wrap(stmt.get_parent_scope())
             check = flow_analysis.break_check(self._evaluator, name_scope,
@@ -57,22 +72,12 @@ class ParserTreeFilter(AbstractFilter):
             if check is flow_analysis.REACHABLE:
                 break
 
-    def get(self, name):
-        try:
-            names = self._used_names[str(name)]
-        except KeyError:
-            return []
-
-        return self._filter(names)
-
-    def values(self):
-        return self._filter(self._used_names.values())
-
 
 class FunctionExecutionFilter(ParserTreeFilter):
-    def __init__(self, parser_scope, executed_function, param_by_name,
+    def __init__(self, evaluator, parser_scope, executed_function, param_by_name,
                  until_position=None, origin_scope=None):
         super(FunctionExecutionFilter, self).__init__(
+            evaluator,
             parser_scope,
             until_position,
             origin_scope
@@ -89,6 +94,17 @@ class FunctionExecutionFilter(ParserTreeFilter):
         return names
 
 
+class GlobalNameFilter(AbstractUsedNamesFilter):
+    def __init__(self, parser_scope, origin_scope=None):
+        super(GlobalNameFilter, self).__init__(parser_scope)
+
+    @to_list
+    def _filter(self, names):
+        for name in names:
+            if name.parent.type == 'global_stmt':
+                yield name
+
+
 def get_global_filters(evaluator, context, until_position):
     """
     Returns all filters in order of priority for name resolution.