Add a ContextSet.

This is not bug free yet, but it's going to be a good abstraction for a lot of small things.

jedi/evaluate/representation.py

@@ -64,6 +64,7 @@ from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter, \
     ContextNameMixin
 from jedi.evaluate import context
 from jedi.evaluate.context import ContextualizedNode
+from jedi.common import NO_CONTEXTS, ContextSet, iterator_to_context_set
 from jedi import parser_utils
 from jedi.evaluate.parser_cache import get_yield_exprs
 
@@ -83,6 +84,7 @@ class ClassName(TreeNameDefinition):
         super(ClassName, self).__init__(parent_context, tree_name)
         self._name_context = name_context
 
+    @iterator_to_context_set
     def infer(self):
         # TODO this _name_to_types might get refactored and be a part of the
         # parent class. Once it is, we can probably just overwrite method to
@@ -162,7 +164,7 @@ class ClassContext(use_metaclass(CachedMetaClass, context.TreeContext)):
 
     def py__call__(self, params):
         from jedi.evaluate.instance import TreeInstance
-        return set([TreeInstance(self.evaluator, self.parent_context, self, params)])
+        return ContextSet(TreeInstance(self.evaluator, self.parent_context, self, params))
 
     def py__class__(self):
         return compiled.create(self.evaluator, type)
@@ -227,7 +229,7 @@ class LambdaName(AbstractNameDefinition):
         return self._lambda_context.tree_node.start_pos
 
     def infer(self):
-        return set([self._lambda_context])
+        return ContextSet(self._lambda_context)
 
 
 class FunctionContext(use_metaclass(CachedMetaClass, context.TreeContext)):
@@ -260,7 +262,7 @@ class FunctionContext(use_metaclass(CachedMetaClass, context.TreeContext)):
         """
         yield_exprs = get_yield_exprs(self.evaluator, self.tree_node)
         if yield_exprs:
-            return set([iterable.Generator(self.evaluator, function_execution)])
+            return ContextSet(iterable.Generator(self.evaluator, function_execution))
         else:
             return function_execution.get_return_values()
 
@@ -312,7 +314,7 @@ class FunctionExecutionContext(context.TreeContext):
         self.tree_node = function_context.tree_node
         self.var_args = var_args
 
-    @evaluator_method_cache(default=set())
+    @evaluator_method_cache(default=NO_CONTEXTS)
     @recursion.execution_recursion_decorator()
     def get_return_values(self, check_yields=False):
         funcdef = self.tree_node
@@ -320,12 +322,12 @@ class FunctionExecutionContext(context.TreeContext):
             return self.evaluator.eval_element(self, funcdef.children[-1])
 
         if check_yields:
-            types = set()
+            context_set = NO_CONTEXTS
             returns = get_yield_exprs(self.evaluator, funcdef)
         else:
             returns = funcdef.iter_return_stmts()
-            types = set(docstrings.infer_return_types(self.function_context))
-            types |= set(pep0484.infer_return_types(self.function_context))
+            context_set = docstrings.infer_return_types(self.function_context)
+            context_set |= pep0484.infer_return_types(self.function_context)
 
         for r in returns:
             check = flow_analysis.reachability_check(self, funcdef, r)
@@ -333,18 +335,18 @@ class FunctionExecutionContext(context.TreeContext):
                 debug.dbg('Return unreachable: %s', r)
             else:
                 if check_yields:
-                    types |= set(self._eval_yield(r))
+                    context_set |= ContextSet(self._eval_yield(r))
                 else:
                     try:
                         children = r.children
                     except AttributeError:
-                        types.add(compiled.create(self.evaluator, None))
+                        context_set |= ContextSet(compiled.create(self.evaluator, None))
                     else:
-                        types |= self.eval_node(children[1])
+                        context_set |= self.eval_node(children[1])
             if check is flow_analysis.REACHABLE:
                 debug.dbg('Return reachable: %s', r)
                 break
-        return types
+        return context_set
 
     def _eval_yield(self, yield_expr):
         if yield_expr.type == 'keyword':
@@ -430,8 +432,10 @@ class ModuleAttributeName(AbstractNameDefinition):
         self.string_name = string_name
 
     def infer(self):
-        return compiled.create(self.parent_context.evaluator, str).execute(
-            param.ValuesArguments([])
+        return ContextSet(
+            compiled.create(self.parent_context.evaluator, str).execute(
+                param.ValuesArguments([])
+            )
         )
 
 
@@ -628,7 +632,7 @@ class ImplicitNSName(AbstractNameDefinition):
         self.string_name = string_name
 
     def infer(self):
-        return []
+        return NO_CONTEXTS
 
     def get_root_context(self):
         return self.implicit_ns_context