Messaging: check the class of the list wrapped by ListSlice_ (#2310)

ListSlice_ can wrap anything that implements List, not just List_. So we
can't assume it's a List_.

---------

Co-authored-by: Kasper Lund <kasper@toit.io>

src/messaging.cc

@@ -179,14 +179,26 @@ bool MessageEncoder::encode_any(Object* object) {
       if (!is_smi(size)) return false;
       return encode_list(instance, 0, Smi::value(size));
     } else if (class_id == program->list_slice_class_id()) {
-      Object* list = instance->at(Instance::LIST_SLICE_LIST_INDEX);
       Object* from_object = instance->at(Instance::LIST_SLICE_FROM_INDEX);
       Object* to_object = instance->at(Instance::LIST_SLICE_TO_INDEX);
       if (!is_smi(from_object) || !is_smi(to_object)) return false;
       word from = Smi::value(from_object);
       word to = Smi::value(to_object);
-      if (is_array(list)) return encode_array(Array::cast(list), from, to);
-      return encode_list(Instance::cast(list), from, to);
+      Object* backing_object = instance->at(Instance::LIST_SLICE_LIST_INDEX);
+      if (is_array(backing_object)) {
+        Array* backing = Array::cast(backing_object);
+        return encode_array(backing, from, to);
+      } else if (is_instance(backing_object)) {
+        Instance* backing = Instance::cast(backing_object);
+        Smi* backing_class_id = backing->class_id();
+        if (backing_class_id != program->list_class_id()) {
+          problematic_class_id_ = Smi::value(backing_class_id);
+          return false;
+        }
+        return encode_list(backing, from, to);
+      } else {
+        return false;
+      }
     } else if (class_id == program->map_class_id()) {
       return encode_map(instance);
     } else if (class_id == program->byte_array_cow_class_id()) {

tests/rpc-test.toit

@@ -167,6 +167,12 @@ test-problematic myself/int -> none:
   test-serialization-failed myself [MyClass]
   test-serialization-failed myself [MySerializable 4]
 
+  // Deques are special lists that we cannot serialize for now.
+  deque := Deque
+  deque.add-all [1, 2, 3, 4]
+  test-serialization-failed myself [deque]
+  test-serialization-failed myself [deque[1..3]]
+
   // Check for cyclic data structure.
   cyclic := []
   cyclic.add cyclic