Enhance the array access API to deal with any objct that implements the list interface.

vm/dart_api_impl.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 831 matching lines @@
     }
     strncpy(res, string_value, string_length + 1);
     ASSERT(res[string_length] == '\0');
     *result = res;
     return Api::Success();
   }
   return Api::Error("Object is not a String");
 }
 
 
+static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
+  if (obj.IsInstance()) {
+    Instance& instance = Instance::Handle();
+    instance ^= obj.raw();
+    const Type& type = Type::Handle(isolate->object_store()->list_interface());
+    return instance.Is(type) ? instance.raw() : Instance::null();
+  }
+  return Instance::null();
+}
+
+
 DART_EXPORT bool Dart_IsArray(Dart_Handle object) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
-  return obj.IsArray();
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  return (obj.IsArray() || (GetListInstance(Isolate::Current(), obj) !=
+                            Instance::null()));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewArray(intptr_t length) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Array& obj = Array::Handle(Array::New(length));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetLength(Dart_Handle array, intptr_t* len) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(array));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     *len = array_obj.Length();
     return Api::Success();
   }
-  return Api::Error("Object is not an Array");
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  // Now check and handle a dart object that implements the List interface.
+  Isolate* isolate = Isolate::Current();
+  const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    String& name = String::Handle(String::New("length"));
+    name = Field::GetterName(name);
+    const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(instance, name, 1, 0));
+    if (!function.IsNull()) {
+      GrowableArray<const Object*> args(0);
+      LongJump* base = isolate->long_jump_base();
+      LongJump jump;
+      isolate->set_long_jump_base(&jump);
+      Dart_Handle result;
+      if (setjmp(*jump.Set()) == 0) {
+        const Array& kNoArgumentNames = Array::Handle();
+        const Instance& retval = Instance::Handle(
+            DartEntry::InvokeDynamic(instance,
+                                     function,
+                                     args,
+                                     kNoArgumentNames));
+        result = Api::Success();
+        if (retval.IsSmi() || retval.IsMint()) {
+          Integer& integer = Integer::Handle();
+          integer ^= retval.raw();
+          *len = integer.AsInt64Value();
+        } else if (retval.IsBigint()) {
+          Bigint& bigint = Bigint::Handle();
+          bigint ^= retval.raw();
+          if (BigintOperations::FitsIntoInt64(bigint)) {
+            *len = BigintOperations::ToInt64(bigint);
+          } else {
+            result = Api::Error("Length of List object is greater than the "
+                                "maximum value that 'len' parameter can hold");
+          }
+        } else {
+          result = Api::Error("Length of List object is not an integer");
+        }
+      } else {
+        SetupErrorResult(&result);
+      }
+      isolate->set_long_jump_base(base);
+      return result;
+    }
+  }
+  return Api::Error("Object does not implement the list inteface");
+}
+
+
+static RawObject* GetArrayAt(Isolate* isolate,
+                             const Instance& instance,
+                             const Integer& index,
+                             const Function& function,
+                             Dart_Handle* result) {
+  ASSERT(isolate != NULL);
+  ASSERT(result != NULL);
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  if (setjmp(*jump.Set()) == 0) {
+    Instance& retval = Instance::Handle();
+    GrowableArray<const Object*> args(0);
+    args.Add(&index);
+    const Array& kNoArgumentNames = Array::Handle();
+    retval = DartEntry::InvokeDynamic(instance,
+                                      function,
+                                      args,
+                                      kNoArgumentNames);
+    if (retval.IsUnhandledException()) {
+      *result = Api::Error("Unexpected exception in '[]'");
+    } else {
+      *result = Api::Success();
+    }
+    isolate->set_long_jump_base(base);
+    return retval.raw();
+  }
+  SetupErrorResult(result);
+  isolate->set_long_jump_base(base);
+  return Object::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ArrayGet(Dart_Handle array,
                                       intptr_t offset,
                                       uint8_t* native_array,
                                       intptr_t length) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(array));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((offset + length) <= array_obj.Length()) {
       Object& element = Object::Handle();
       Integer& integer  = Integer::Handle();
       for (int i = 0; i < length; i++) {
         element = array_obj.At(offset + i);
         integer ^= element.raw();
         native_array[i] = static_cast<uint8_t>(integer.AsInt64Value() & 0xff);
         ASSERT(integer.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
       }
       return Api::Success();
     }
     return Api::Error("Invalid length passed in to access array elements");
   }
-  return Api::Error("Object is not an Array");
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  // Now check and handle a dart object that implements the List interface.
+  Isolate* isolate = Isolate::Current();
+  const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    String& name = String::Handle(String::New("[]"));
+    const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(instance, name, 2, 0));
+    if (!function.IsNull()) {
+      Object& element = Object::Handle();
+      Integer& intobj = Integer::Handle();
+      Dart_Handle result;
+      for (int i = 0; i < length; i++) {
+        intobj = Integer::New(offset + i);
+        element = GetArrayAt(isolate, instance, intobj, function, &result);
+        if (!Dart_IsValid(result)) {
+          return result;  // Error condition.
+        }
+        intobj ^= element.raw();
+        ASSERT(intobj.AsInt64Value() <= 0xff);
+        // TODO(hpayer): value should always be smaller then 0xff. Add error
+        // handling.
+        native_array[i] = static_cast<uint8_t>(intobj.AsInt64Value() & 0xff);
+      }
+      return Api::Success();
+    }
+  }
+  return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ArrayGetAt(Dart_Handle array, intptr_t index) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(array));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((index >= 0) && (index < array_obj.Length())) {
       const Object& element = Object::Handle(array_obj.At(index));
       return Api::NewLocalHandle(element);
     }
     return Api::Error("Invalid index passed in to access array element");
   }
-  return Api::Error("Object is not an Array");
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  // Now check and handle a dart object that implements the List interface.
+  Isolate* isolate = Isolate::Current();
+  const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    String& name = String::Handle(String::New("[]"));
+    const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(instance, name, 2, 0));
+    if (!function.IsNull()) {
+      Object& element = Object::Handle();
+      Integer& indexobj = Integer::Handle();
+      Dart_Handle result;
+      indexobj = Integer::New(index);
+      element = GetArrayAt(isolate, instance, indexobj, function, &result);
+      if (!Dart_IsValid(result)) {
+        return result;  // Error condition.
+      }
+      return Api::NewLocalHandle(element);
+    }
+  }
+  return Api::Error("Object does not implement the 'List' interface");
+}
+
+
+static void SetArrayAt(Isolate* isolate,
+                       const Instance& instance,
+                       const Integer& index,
+                       const Object& value,
+                       const Function& function,
+                       Dart_Handle* result) {
+  ASSERT(isolate != NULL);
+  ASSERT(result != NULL);
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  if (setjmp(*jump.Set()) == 0) {
+    GrowableArray<const Object*> args(1);
+    args.Add(&index);
+    args.Add(&value);
+    Instance& retval = Instance::Handle();
+    const Array& kNoArgumentNames = Array::Handle();
+    retval = DartEntry::InvokeDynamic(instance,
+                                      function,
+                                      args,
+                                      kNoArgumentNames);
+    if (retval.IsUnhandledException()) {
+      *result = Api::Error("Unexpected exception in '[]='");
+    } else {
+      *result = Api::Success();
+    }
+  } else {
+    SetupErrorResult(result);
+  }
+  isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ArraySet(Dart_Handle array,
                                       intptr_t offset,
                                       uint8_t* native_array,
                                       intptr_t length) {
   Zone zone;
   HandleScope scope;
   const Object& obj = Object::Handle(Api::UnwrapHandle(array));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     Integer& integer = Integer::Handle();
     if ((offset + length) <= array_obj.Length()) {
       for (int i = 0; i < length; i++) {
         integer ^= Integer::New(native_array[i]);
         array_obj.SetAt(offset + i, integer);
       }
       return Api::Success();
     }
     return Api::Error("Invalid length passed in to set array elements");
   }
-  return Api::Error("Object is not an Array");
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  // Now check and handle a dart object that implements the List interface.
+  Isolate* isolate = Isolate::Current();
+  const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    String& name = String::Handle(String::New("[]="));
+    const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(instance, name, 3, 0));
+    if (!function.IsNull()) {
+      Integer& indexobj = Integer::Handle();
+      Integer& valueobj = Integer::Handle();
+      Dart_Handle result;
+      for (int i = 0; i < length; i++) {
+        indexobj = Integer::New(offset + i);
+        valueobj ^= Integer::New(native_array[i]);
+        SetArrayAt(isolate, instance, indexobj, valueobj, function, &result);
+        if (!Dart_IsValid(result)) {
+          return result;  // Error condition.
+        }
+      }
+      return Api::Success();
+    }
+  }
+  return Api::Error("Object does not implement the 'List' interface");
 }
 
+
 DART_EXPORT Dart_Handle Dart_ArraySetAt(Dart_Handle array,
                                         intptr_t index,
                                         Dart_Handle value) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& obj = Object::Handle(Api::UnwrapHandle(array));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
     if ((index >= 0) && (index < array_obj.Length())) {
       array_obj.SetAt(index, value_obj);
       return Api::Success();
     }
     return Api::Error("Invalid index passed in to set array element");
   }
-  return Api::Error("Object is not an Array");
+  // TODO(5526318): Make access to GrowableObjectArray more efficient.
+  // Now check and handle a dart object that implements the List interface.
+  Isolate* isolate = Isolate::Current();
+  const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    String& name = String::Handle(String::New("[]="));
+    const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(instance, name, 3, 0));
+    if (!function.IsNull()) {
+      Dart_Handle result;
+      const Integer& index_obj = Integer::Handle(Integer::New(index));
+      const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
+      SetArrayAt(isolate, instance, index_obj, value_obj, function, &result);
+      return result;
+    }
+  }
+  return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
 static void InvokeStatic(const Function& function,
                          GrowableArray<const Object*>& args,
                          Dart_Handle* result) {
   Isolate* isolate = Isolate::Current();
@@ skipping 795 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart