Create separate classes for FakeSequence

jedi/inference/arguments.py

@@ -84,7 +84,7 @@ def _iterate_argument_clinic(inference_state, arguments, parameters):
                     break
 
                 lazy_values.append(argument)
-            yield ValueSet([iterable.FakeSequence(inference_state, u'tuple', lazy_values)])
+            yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)])
             lazy_values
             continue
         elif stars == 2:

jedi/inference/docstrings.py

@@ -253,8 +253,8 @@ def _execute_array_values(inference_state, array):
     Tuples indicate that there's not just one return value, but the listed
     ones.  `(str, int)` means that it returns a tuple with both types.
     """
-    from jedi.inference.value.iterable import SequenceLiteralValue, FakeSequence
-    if isinstance(array, SequenceLiteralValue):
+    from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList
+    if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'):
         values = []
         for lazy_value in array.py__iter__():
             objects = ValueSet.from_sets(
@@ -262,7 +262,8 @@ def _execute_array_values(inference_state, array):
                 for typ in lazy_value.infer()
             )
             values.append(LazyKnownValues(objects))
-        return {FakeSequence(inference_state, array.array_type, values)}
+        cls = FakeTuple if array.array_type == 'tuple' else FakeList
+        return {cls(inference_state, values)}
     else:
         return array.execute_annotation()
 

jedi/inference/param.py

@@ -134,7 +134,7 @@ def get_executed_param_names_and_issues(execution_context, arguments):
                         var_arg_iterator.push_back((key, argument))
                         break
                     lazy_value_list.append(argument)
-            seq = iterable.FakeSequence(execution_context.inference_state, u'tuple', lazy_value_list)
+            seq = iterable.FakeTuple(execution_context.inference_state, lazy_value_list)
             result_arg = LazyKnownValue(seq)
         elif param.star_count == 2:
             if argument is not None:
@@ -224,7 +224,7 @@ def _error_argument_count(funcdef, actual_count):
 def _create_default_param(execution_context, param):
     if param.star_count == 1:
         result_arg = LazyKnownValue(
-            iterable.FakeSequence(execution_context.inference_state, u'tuple', [])
+            iterable.FakeTuple(execution_context.inference_state, [])
         )
     elif param.star_count == 2:
         result_arg = LazyKnownValue(

jedi/inference/value/iterable.py

@@ -298,15 +298,14 @@ class DictComprehension(ComprehensionMixin, Sequence):
     @publish_method('values')
     def _imitate_values(self):
         lazy_value = LazyKnownValues(self._dict_values())
-        return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])])
+        return ValueSet([FakeList(self.inference_state, [lazy_value])])
 
     @publish_method('items')
     def _imitate_items(self):
         lazy_values = [
             LazyKnownValue(
-                FakeSequence(
+                FakeTuple(
                     self.inference_state,
-                    u'tuple',
                     [LazyKnownValues(key),
                      LazyKnownValues(value)]
                 )
@@ -314,7 +313,7 @@ class DictComprehension(ComprehensionMixin, Sequence):
             for key, value in self._iterate()
         ]
 
-        return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)])
+        return ValueSet([FakeList(self.inference_state, lazy_values)])
 
     def get_mapping_item_values(self):
         return self._dict_keys(), self._dict_values()
@@ -469,19 +468,19 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue):
     @publish_method('values')
     def _imitate_values(self):
         lazy_value = LazyKnownValues(self._dict_values())
-        return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])])
+        return ValueSet([FakeList(self.inference_state, [lazy_value])])
 
     @publish_method('items')
     def _imitate_items(self):
         lazy_values = [
-            LazyKnownValue(FakeSequence(
-                self.inference_state, u'tuple',
+            LazyKnownValue(FakeTuple(
+                self.inference_state,
                 (LazyTreeValue(self._defining_context, key_node),
                  LazyTreeValue(self._defining_context, value_node))
             )) for key_node, value_node in self.get_tree_entries()
         ]
 
-        return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)])
+        return ValueSet([FakeList(self.inference_state, lazy_values)])
 
     def _dict_keys(self):
         return ValueSet.from_sets(
@@ -493,14 +492,13 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue):
         return self._dict_keys(), self._dict_values()
 
 
-class FakeSequence(Sequence):
-    def __init__(self, inference_state, array_type, lazy_value_list):
+class _FakeSequence(Sequence):
+    def __init__(self, inference_state, lazy_value_list):
         """
         type should be one of "tuple", "list"
         """
-        super(FakeSequence, self).__init__(inference_state)
+        super(_FakeSequence, self).__init__(inference_state)
         self._lazy_value_list = lazy_value_list
-        self.array_type = array_type
 
     def py__simple_getitem__(self, index):
         if isinstance(index, slice):
@@ -520,6 +518,14 @@ class FakeSequence(Sequence):
         return "<%s of %s>" % (type(self).__name__, self._lazy_value_list)
 
 
+class FakeTuple(_FakeSequence):
+    array_type = u'tuple'
+
+
+class FakeList(_FakeSequence):
+    array_type = u'tuple'
+
+
 class FakeDict(_DictMixin, Sequence):
     array_type = u'dict'
 
@@ -553,8 +559,8 @@ class FakeDict(_DictMixin, Sequence):
 
     @publish_method('values')
     def _values(self):
-        return ValueSet([FakeSequence(
-            self.inference_state, u'tuple',
+        return ValueSet([FakeTuple(
+            self.inference_state,
             [LazyKnownValues(self._dict_values())]
         )])
 

jedi/plugins/stdlib.py

@@ -643,9 +643,8 @@ class ItemGetterCallable(ValueWrapper):
                 # TODO we need to add the contextualized value.
                 value_set |= item_value_set.get_item(lazy_values[0].infer(), None)
             else:
-                value_set |= ValueSet([iterable.FakeSequence(
+                value_set |= ValueSet([iterable.FakeList(
                     self._wrapped_value.inference_state,
-                    'list',
                     [
                         LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None))
                         for lazy_value in lazy_values