Move process_precedence_element from the Evaluator to the precedence module.

jedi/evaluate/__init__.py

@@ -169,22 +169,7 @@ class Evaluator(object):
         """
         debug.dbg('eval_expression_list: %s', expression_list)
         p = precedence.create_precedence(expression_list)
-        return self.process_precedence_element(p) or []
+        return precedence.process_precedence_element(self, p) or []
-
-    def process_precedence_element(self, el):
-        if el is None:
-            return None
-        else:
-            if isinstance(el, precedence.Precedence):
-                return self._eval_precedence(el)
-            else:
-                # normal element, no operators
-                return self.eval_statement_element(el)
-
-    def _eval_precedence(self, _precedence):
-        left = self.process_precedence_element(_precedence.left)
-        right = self.process_precedence_element(_precedence.right)
-        return precedence.calculate(self, left, _precedence.operator, right)
 
     def eval_statement_element(self, element):
         if pr.Array.is_type(element, pr.Array.NOARRAY):

jedi/evaluate/iterable.py

@@ -490,7 +490,7 @@ class Slice(object):
             if element is None:
                 return None
 
-            result = self._evaluator.process_precedence_element(element)
+            result = precedence.process_precedence_element(self._evaluator, element)
             if len(result) != 1:
                 # We want slices to be clear defined with just one type.
                 # Otherwise we will return an empty slice object.
@@ -528,4 +528,4 @@ def create_indexes_or_slices(evaluator, index_array):
             step = None
         return (Slice(evaluator, start, stop, step),)
     else:
-        return tuple(evaluator.process_precedence_element(prec))
+        return tuple(precedence.process_precedence_element(evaluator, prec))

jedi/evaluate/precedence.py

@@ -214,6 +214,19 @@ def _literals_to_types(evaluator, result):
     return list(set(result))
 
 
+def process_precedence_element(evaluator, precedence):
+    if precedence is None:
+        return None
+    else:
+        if isinstance(precedence, Precedence):
+            left = process_precedence_element(evaluator, precedence.left)
+            right = process_precedence_element(evaluator, precedence.right)
+            return calculate(evaluator, left, precedence.operator, right)
+        else:
+            # normal element, no operators
+            return evaluator.eval_statement_element(precedence)
+
+
 def calculate(evaluator, left_result, operator, right_result):
     result = []
     if left_result is None and right_result:

test/completion/flow_analysis.py

@@ -172,6 +172,10 @@ def isinst(x):
 isinst(A())
 #? set
 isinst(True)
+#? set
+isinst(1)
+#? int
+isinst(2)
 #? list
 isinst(1.0)
 #? list