feat(Map): support constructor initialization with MapInitialEntries

- Added new type alias `MapInitialEntries<K, V>` = { key: K, value: V }[]
- Map constructor now accepts:
  • An array of { key, value } objects
  • Any array typed as MapInitialEntries<K,V>
- This allows populating a Map in one step with strong typing.
- Example:

  let myMap = new Map<string, i32>([
    { key: "a", value: 1 },
    { key: "b", value: 2 },
  ]);

  let init: MapInitialEntries<string, i32> = [
    { key: "x", value: 10 },
    { key: "y", value: 20 },
  ];
  let anotherMap = new Map<string, i32>(init);

Author: pebrianz

NOTICE

@@ -60,6 +60,7 @@ under the licensing terms detailed in LICENSE:
 * Fabián Heredia Montiel <[email protected]>
 * Jonas Minnberg <[email protected]>
 * Kam Chehresa <[email protected]>
+* Pebrian <[email protected]>
 
 Portions of this software are derived from third-party works licensed under
 the following terms:

std/assembly/index.d.ts

@@ -2394,7 +2394,7 @@ interface NewableFunction extends Function {
 interface IArguments {}
 interface RegExp {}
 
-declare class Map<K,V> {
+interface Map<K,V> {
   readonly size: i32;
   has(key: K): bool;
   set(key: K, value: V): this;
@@ -2406,6 +2406,14 @@ declare class Map<K,V> {
   toString(): string;
 }
 
+type MapInitialEntries<K,V> = {key: V, value:V}[]
+
+interface MapConstructor {
+  new <K, V>(entries?: MapInitialEntries<K,V>): Map<K,V>;
+}
+
+declare const Map: MapConstructor;
+
 declare class Set<K> {
   readonly size: i32;
   has(value: K): bool;

std/assembly/map.ts

@@ -54,6 +54,13 @@ function ENTRY_SIZE<K,V>(): usize {
   return size;
 }
 
+class KeyValue<K,V> {
+  key: K;
+  value: V;
+}
+
+export type MapInitialEntries<K,V> = KeyValue<K,V>[];
+
 export class Map<K,V> {
 
   // buckets referencing their respective first entry, usize[bucketsMask + 1]
@@ -66,8 +73,44 @@ export class Map<K,V> {
   private entriesOffset: i32 = 0;
   private entriesCount: i32 = 0;
 
-  constructor() {
-    /* nop */
+  constructor(initialEntries: MapInitialEntries<K,V> = []) {
+    let entriesLength = initialEntries.length;
+
+    if(entriesLength > 0) { 
+      if(entriesLength >= this.entriesCapacity) this.bucketsMask = entriesLength;
+      this.rehash((this.bucketsMask << 1) | 1);
+
+      for(let i = 0; i < entriesLength; i++){
+        let key = initialEntries[i].key;
+        let value = initialEntries[i].value;
+        let hashCode = HASH<K>(key);
+        let entry = this.find(key, hashCode); // unmanaged!
+        if (entry) {
+          entry.value = value;
+          if (isManaged<V>()) {
+            __link(changetype<usize>(this), changetype<usize>(value), true);
+          }
+        } else {
+          // append new entry
+          let entries = this.entries;
+          let entry = changetype<MapEntry<K,V>>(changetype<usize>(entries) + <usize>(this.entriesOffset++) * ENTRY_SIZE<K,V>());
+          // link with the map
+          entry.key = key;
+          if (isManaged<K>()) {
+            __link(changetype<usize>(this), changetype<usize>(key), true);
+          }
+          entry.value = value;
+          if (isManaged<V>()) {
+            __link(changetype<usize>(this), changetype<usize>(value), true);
+          }
+          ++this.entriesCount;
+          // link with previous entry in bucket
+          let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
+          entry.taggedNext = load<usize>(bucketPtrBase);
+          store<usize>(bucketPtrBase, changetype<usize>(entry));
+        }
+      }
+    }
   }
 
   get size(): i32 {

tests/compiler/std/map.ts

@@ -1,3 +1,4 @@
+
 function testNumeric<K extends number,V extends number>(): void {
   var map = new Map<K,V>();
 
@@ -58,6 +59,26 @@ function testNumeric<K extends number,V extends number>(): void {
   // clear
   map.clear();
   assert(map.size == 0);
+  
+  const initialEntries: MapInitialEntries<K,V> = [];
+
+  for(let k: K = 0; k < 100; ++k){
+    initialEntries.push({
+      key: k,
+      value: 10 + <V>k
+    });
+  }
+
+  map = new Map<K,V>(initialEntries);
+
+  assert(map.size == 100);
+  for(let k: K = 0; k < 100; ++k){
+    assert(map.has(k));
+    assert(map.get(k) == 10 + <V>k);
+    map.delete(k);
+    assert(!map.has(k));
+  }
+  assert(map.size == 0);
 }
 
 testNumeric<i8,i32>();