diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 4317487f..c05722a3 100644
--- a/jedi/evaluate/__init__.py
+++ b/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 []
-
-    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)
+        return precedence.process_precedence_element(self, p) or []
 
     def eval_statement_element(self, element):
         if pr.Array.is_type(element, pr.Array.NOARRAY):
diff --git a/jedi/evaluate/iterable.py b/jedi/evaluate/iterable.py
index ae0817bc..eaf578c7 100644
--- a/jedi/evaluate/iterable.py
+++ b/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))
diff --git a/jedi/evaluate/precedence.py b/jedi/evaluate/precedence.py
index 05497f47..d74d31cf 100644
--- a/jedi/evaluate/precedence.py
+++ b/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:
diff --git a/test/completion/flow_analysis.py b/test/completion/flow_analysis.py
index 65ae8dd4..da6cd39e 100644
--- a/test/completion/flow_analysis.py
+++ b/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