[vm] Add C Api for maps making.

Also allow to write simple conversions from std::map to "Dart Map" using
"c++ template magic".

[email protected]

TEST=vm/cc/DartAPI_MapCreate

Bug: nothing
Change-Id: I11f3271df6880825bd417ee5532c56bacfa7278d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/449280
Auto-Submit: Art Snake <[email protected]>
Commit-Queue: Slava Egorov <[email protected]>
Reviewed-by: Alexander Markov <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: art-snake

runtime/bin/dart_api_win.c

@@ -244,6 +244,10 @@ typedef Dart_Handle (*Dart_ListSetAsBytesType)(Dart_Handle,
 typedef Dart_Handle (*Dart_MapGetAtType)(Dart_Handle, Dart_Handle);
 typedef Dart_Handle (*Dart_MapContainsKeyType)(Dart_Handle, Dart_Handle);
 typedef Dart_Handle (*Dart_MapKeysType)(Dart_Handle);
+typedef Dart_Handle (*Dart_NewMapType)(Dart_Handle,
+                                       Dart_Handle,
+                                       Dart_Handle,
+                                       Dart_Handle);
 typedef Dart_TypedData_Type (*Dart_GetTypeOfTypedDataType)(Dart_Handle);
 typedef Dart_TypedData_Type (*Dart_GetTypeOfExternalTypedDataType)(Dart_Handle);
 typedef Dart_Handle (*Dart_NewTypedDataType)(Dart_TypedData_Type, intptr_t);
@@ -650,6 +654,7 @@ static Dart_ListSetAsBytesType Dart_ListSetAsBytesFn = NULL;
 static Dart_MapGetAtType Dart_MapGetAtFn = NULL;
 static Dart_MapContainsKeyType Dart_MapContainsKeyFn = NULL;
 static Dart_MapKeysType Dart_MapKeysFn = NULL;
+static Dart_NewMapType Dart_NewMapFn = NULL;
 static Dart_GetTypeOfTypedDataType Dart_GetTypeOfTypedDataFn = NULL;
 static Dart_GetTypeOfExternalTypedDataType Dart_GetTypeOfExternalTypedDataFn =
     NULL;
@@ -1135,6 +1140,7 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
     Dart_MapContainsKeyFn =
         (Dart_MapContainsKeyType)GetProcAddress(process, "Dart_MapContainsKey");
     Dart_MapKeysFn = (Dart_MapKeysType)GetProcAddress(process, "Dart_MapKeys");
+    Dart_NewMapFn = (Dart_NewMapType)GetProcAddress(process, "Dart_NewMap");
     Dart_GetTypeOfTypedDataFn = (Dart_GetTypeOfTypedDataType)GetProcAddress(
         process, "Dart_GetTypeOfTypedData");
     Dart_GetTypeOfExternalTypedDataFn =
@@ -2161,6 +2167,13 @@ Dart_Handle Dart_MapKeys(Dart_Handle map) {
   return Dart_MapKeysFn(map);
 }
 
+Dart_Handle Dart_NewMap(Dart_Handle keys_type,
+                        Dart_Handle keys_handle,
+                        Dart_Handle values_type,
+                        Dart_Handle values_handle) {
+  return Dart_NewMapFn(keys_type, keys_handle, values_type, values_handle);
+}
+
 Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object) {
   return Dart_GetTypeOfTypedDataFn(object);
 }

runtime/include/dart_api.h

@@ -2603,6 +2603,26 @@ DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key);
  */
 DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map);
 
+/**
+ * Returns a Map filled by key value pairs from the provided lists.
+ *
+ * \param keys_type Handle to a type of keys. E.g., from
+ *   Dart_Get<XXX>Type.
+ * \param keys_handle Handle to a list with keys. E.g., from
+ *   Dart_NewList<XXX>.
+ * \param values_type Handle to a type of values. E.g., from
+ *   Dart_Get<XXX>Type.
+ * \param values_handle Handle to a list with values. E.g., from
+ *   Dart_NewList<XXX>.
+ *
+ * \return The Map object if no error occurs. Otherwise returns
+ *   an error handle.
+ */
+DART_EXPORT Dart_Handle Dart_NewMap(Dart_Handle keys_type,
+                                    Dart_Handle keys_handle,
+                                    Dart_Handle values_type,
+                                    Dart_Handle values_handle);
+
 /*
  * ==========
  * Typed Data

runtime/tests/vm/dart/exported_symbols_test.dart

@@ -255,6 +255,7 @@ main() {
     "Dart_NewList",
     "Dart_NewListOfType",
     "Dart_NewListOfTypeFilled",
+    "Dart_NewMap",
     "Dart_NewNativePort",
     "Dart_NewPersistentHandle",
     "Dart_NewSendPort",

runtime/vm/dart_api_impl.cc

@@ -3174,6 +3174,76 @@ DART_EXPORT Dart_Handle Dart_NewListOfType(Dart_Handle element_type,
   return Api::NewHandle(T, Array::New(length, type));
 }
 
+DART_EXPORT Dart_Handle Dart_NewMap(Dart_Handle keys_type,
+                                    Dart_Handle keys_handle,
+                                    Dart_Handle values_type,
+                                    Dart_Handle values_handle) {
+  {  // Validate that keys and values are lists.
+    if (!Dart_IsList(keys_handle)) {
+      return Api::NewError("%s expects argument 'keys_handle' to be a list.",
+                           CURRENT_FUNC);
+    }
+    if (!Dart_IsList(values_handle)) {
+      return Api::NewError("%s expects argument 'values_handle' to be a list.",
+                           CURRENT_FUNC);
+    }
+  }
+  {  // Validate length of keys and values
+    intptr_t keys_len = 0;
+    intptr_t values_len = 0;
+    Dart_Handle api_result = Dart_ListLength(keys_handle, &keys_len);
+    if (Dart_IsError(api_result)) {
+      return api_result;
+    }
+    api_result = Dart_ListLength(values_handle, &values_len);
+    if (Dart_IsError(api_result)) {
+      return api_result;
+    }
+    if (keys_len != values_len) {
+      return Api::NewError(
+          "%s expects length of 'keys_handle' list to be equal to length of "
+          "'values_handle' list.",
+          CURRENT_FUNC);
+    }
+  }
+
+  DARTSCOPE(Thread::Current());
+  CHECK_CALLBACK_STATE(T);
+
+  const Type& keys_type_obj = Api::UnwrapTypeHandle(Z, keys_type);
+  if (keys_type_obj.IsNull()) {
+    RETURN_TYPE_ERROR(Z, keys_type, Type);
+  }
+  const Type& values_type_obj = Api::UnwrapTypeHandle(Z, values_type);
+  if (values_type_obj.IsNull()) {
+    RETURN_TYPE_ERROR(Z, values_type, Type);
+  }
+  const Object& keys_obj = Object::Handle(Z, Api::UnwrapHandle(keys_handle));
+  const Object& values_obj =
+      Object::Handle(Z, Api::UnwrapHandle(values_handle));
+
+  // Init type arguments
+  auto& type_arguments =
+      TypeArguments::Handle(Z, TypeArguments::New(2, Heap::kOld));
+  type_arguments.SetTypeAt(0, keys_type_obj);
+  type_arguments.SetTypeAt(1, values_type_obj);
+  type_arguments ^= type_arguments.Canonicalize(T);
+
+  const Class& map_class =
+      Class::Handle(Z, T->isolate_group()->object_store()->map_class());
+  map_class.EnsureIsFinalized(T);
+
+  // Invoke Map._fromKeysValue class factory:
+  Function& factory_method = Function::ZoneHandle(Z);
+  factory_method = map_class.LookupFactoryAllowPrivate(
+      Library::PrivateCoreLibName(Symbols::MapKeyValuesFactory()));
+  const Array& args = Array::Handle(Z, Array::New(3));
+  args.SetAt(0, type_arguments);
+  args.SetAt(1, keys_obj);
+  args.SetAt(2, values_obj);
+  return Api::NewHandle(T, DartEntry::InvokeFunction(factory_method, args));
+}
+
 DART_EXPORT Dart_Handle Dart_NewListOfTypeFilled(Dart_Handle element_type,
                                                  Dart_Handle fill_object,
                                                  intptr_t length) {

runtime/vm/dart_api_impl_test.cc

@@ -2262,6 +2262,122 @@ TEST_CASE(DartAPI_MapAccess) {
   EXPECT(Dart_IsError(Dart_MapKeys(a)));
 }
 
+TEST_CASE(DartAPI_MapCreate) {
+  const char* kScriptChars =
+      R"(
+@pragma('vm:entry-point', 'call')
+String testMain(Map<String, Object?> mp) {
+    List result = [];
+    String dump = "";
+    // Test no modifications
+    for (var k in mp.keys) {
+        dump += "|" + k + ":" + mp[k].toString() + "|";
+    }
+    result.add(dump);
+    
+    dump = "";
+    // Test with modifications
+    mp["f"] = 42;
+    for (var k in mp.keys) {
+        dump += "|" + k + ":" + mp[k].toString() + "|";
+    }
+    result.add(dump);
+    return result.toString();
+})";
+  // Create a test library and Load up a test script in it.
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
+
+  Dart_Handle core_lib = Dart_LookupLibrary(NewString("dart:core"));
+  EXPECT_VALID(core_lib);
+
+  Dart_Handle key_type =
+      Dart_GetNonNullableType(core_lib, NewString("String"), 0, nullptr);
+  EXPECT_VALID(key_type);
+
+  Dart_Handle value_type =
+      Dart_GetNullableType(core_lib, NewString("Object"), 0, nullptr);
+  EXPECT_VALID(value_type);
+
+  {  // Test empty
+    // Init list of keys
+    Dart_Handle keys = Dart_NewList(0);
+    EXPECT_VALID(keys);
+
+    // Init list of values
+    Dart_Handle values = Dart_NewList(0);
+    EXPECT_VALID(values);
+
+    Dart_Handle dart_map = Dart_NewMap(key_type, keys, value_type, values);
+
+    // Invoke a function which returns an object of type String.
+    Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, &dart_map);
+    EXPECT_VALID(result);
+    const char* encoded_str = nullptr;
+    EXPECT_VALID(Dart_StringToCString(result, &encoded_str));
+    EXPECT_STREQ("[, |f:42|]", encoded_str);
+  }
+  {  // Test 5 elements
+    // Init list of keys
+    Dart_Handle keys = Dart_NewList(5);
+    EXPECT_VALID(keys);
+
+    // Init list of values
+    Dart_Handle values = Dart_NewList(5);
+    EXPECT_VALID(values);
+
+    // Fill map.
+    EXPECT_VALID(Dart_ListSetAt(keys, 0, NewString("a")));
+    EXPECT_VALID(Dart_ListSetAt(values, 0, Dart_NewInteger(5)));
+    EXPECT_VALID(Dart_ListSetAt(keys, 1, NewString("b")));
+    EXPECT_VALID(Dart_ListSetAt(values, 1, Dart_NewInteger(4)));
+    EXPECT_VALID(Dart_ListSetAt(keys, 2, NewString("c")));
+    EXPECT_VALID(Dart_ListSetAt(values, 2, NewString("oO")));
+    EXPECT_VALID(Dart_ListSetAt(keys, 3, NewString("d")));
+    EXPECT_VALID(Dart_ListSetAt(values, 3, Dart_NewInteger(2)));
+    EXPECT_VALID(Dart_ListSetAt(keys, 4, NewString("e")));
+    EXPECT_VALID(Dart_ListSetAt(values, 4, Dart_Null()));
+    Dart_Handle dart_map = Dart_NewMap(key_type, keys, value_type, values);
+
+    // Invoke a function which returns an object of type String.
+    Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, &dart_map);
+    EXPECT_VALID(result);
+    const char* encoded_str = nullptr;
+    EXPECT_VALID(Dart_StringToCString(result, &encoded_str));
+    EXPECT_STREQ(
+        "[|a:5||b:4||c:oO||d:2||e:null|, "
+        "|a:5||b:4||c:oO||d:2||e:null||f:42|]",
+        encoded_str);
+  }
+  {  // Test 10 elements
+    static constexpr int kElementCount = 10;
+    // Init list of keys
+    Dart_Handle keys = Dart_NewList(kElementCount);
+    EXPECT_VALID(keys);
+
+    // Init list of values
+    Dart_Handle values = Dart_NewList(kElementCount);
+    EXPECT_VALID(values);
+
+    // Fill map.
+    for (int i = 0; i < kElementCount; ++i) {
+      const char key[2] = {static_cast<char>('a' + i), '\0'};
+      EXPECT_VALID(Dart_ListSetAt(keys, i, NewString(key)));
+      EXPECT_VALID(Dart_ListSetAt(values, i, Dart_NewInteger(i)));
+    }
+    Dart_Handle dart_map = Dart_NewMap(key_type, keys, value_type, values);
+
+    // Invoke a function which returns an object of type String.
+    Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, &dart_map);
+    EXPECT_VALID(result);
+    const char* encoded_str = nullptr;
+    EXPECT_VALID(Dart_StringToCString(result, &encoded_str));
+    EXPECT_STREQ(
+        "[|a:0||b:1||c:2||d:3||e:4||f:5||g:6||h:7||i:8||j:9|, "
+        "|a:0||b:1||c:2||d:3||e:4||f:42||g:6||h:7||i:8||j:9|]",
+        encoded_str);
+  }
+}
+
 TEST_CASE(DartAPI_IsFuture) {
   const char* kScriptChars =
       "import 'dart:async';"

runtime/vm/symbols.h

@@ -207,6 +207,7 @@ class ObjectPointerVisitor;
   V(LocalVarDescriptors, "LocalVarDescriptors")                                \
   V(Map, "Map")                                                                \
   V(MapLiteralFactory, "Map._fromLiteral")                                     \
+  V(MapKeyValuesFactory, "Map._fromKeyValues")                                 \
   V(MegamorphicCache, "MegamorphicCache")                                      \
   V(MonomorphicSmiableCall, "MonomorphicSmiableCall")                          \
   V(MoveNext, "moveNext")                                                      \

sdk/lib/_internal/vm_shared/lib/map_patch.dart

@@ -23,6 +23,18 @@ class Map<K, V> {
     return map;
   }
 
+  // Factory constructing a Map for Dart_NewMap C API
+  // from list of keys and values.
+  @pragma("vm:entry-point", "call")
+  factory Map._fromKeyValues(List keys, List values) {
+    var map = LinkedHashMap<K, V>();
+    var len = keys.length;
+    for (int i = 0; i < len; i++) {
+      map[keys[i]] = values[i];
+    }
+    return map;
+  }
+
   @patch
   factory Map.unmodifiable(Map other) {
     return UnmodifiableMapView<K, V>(Map<K, V>.from(other));