Implement Array#sort (#57)

tests/compiler/std/array.ts

@@ -1,5 +1,86 @@
 import "allocator/arena";
 
+// Default comparator
+function createDefaultComparator<T>(): (a: T, b: T) => i32 {
+  return (a: T, b: T): i32 => (
+    <i32>(a > b) - <i32>(a < b)
+  );
+}
+
+// Check is array sorted
+function isSorted<T>(data: Array<T>, comparator: (a: T, b: T) => i32 = createDefaultComparator<T>()): bool {
+  for (let i: i32 = 1, len: i32 = data.length; i < len; i++) {
+    if (comparator(data[i - 1], data[i]) > 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Check is equality for arrays
+function isArraysEqual<T>(a: Array<T>, b: Array<T>, maxLen: i32 = 0): bool {
+  var len = maxLen;
+  if (!maxLen) {
+    if (a.length != b.length) {
+      return false;
+    }
+    len = <i32>a.length;
+  }
+  for (let i: i32 = 0; i < len; i++) {
+    if (a[i] != b[i]) return false;
+  }
+  return true;
+}
+
+function createReverseOrderedArray(size: i32): Array<i32> {
+  var arr = new Array<i32>(size);
+  for (let i: i32 = 0; i < arr.length; i++) {
+    arr[i] = <i32>arr.length - 1 - i;
+  }
+  return arr;
+}
+
+NativeMath.seedRandom(reinterpret<u64>(JSMath.random()));
+
+function createRandomOrderedArray(size: i32): Array<i32> {
+  var arr = new Array<i32>(size);
+  for (let i: i32 = 0; i < arr.length; i++) {
+    arr[i] = <i32>(NativeMath.random() * arr.length);
+  }
+  return arr;
+}
+
+/*
+function createReverseOrderedNestedArray(size: i32): Array<Array<i32>> {
+  var arr = new Array<Array<i32>>(size);
+  for (let i: i32 = 0; i < arr.length; i++) {
+    arr[i] = new Array<i32>(1);
+    arr[i][0] = arr.length - 1 - i;
+  }
+  return arr;
+}
+
+class Proxy<T> {
+  constructor(public x: T) {}
+}
+
+function createReverseOrderedElementsArray(size: i32): Proxy<i32>[] {
+  var arr = new Array<Proxy<i32>>(size);
+  for (let i: i32 = 0; i < arr.length; i++) {
+    arr[i] = new Proxy<i32>(arr.length - 1 - i);
+  }
+  return arr;
+}
+*/
+
+function assertSorted<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): void {
+  assert(isSorted<T>(arr.sort<T>(comparator), comparator));
+}
+
+function assertSortedDefault<T>(arr: Array<T>): void {
+  assertSorted<T>(arr, createDefaultComparator<T>());
+}
+
 var arr = changetype<i32[]>(allocate_memory(sizeof<usize>() + 2 * sizeof<i32>()));
 
 assert(arr.length == 0);
@@ -323,3 +404,66 @@ i = arr.reduce<i32>(((prev: i32, current: i32, index: i32, array: Array<i32>): i
 // only 2 first items was reduced, since last 2 was removed by .pop()
 assert(i == 1);
 assert(arr.length == 2);
+
+/*=============================== sort ==========================*/
+
+var revesed0: Array<i32> = [];
+var revesed1: Array<i32> = [1];
+var revesed2: Array<i32> = [2, 1];
+var revesed4: Array<i32> = [3, 2, 1, 0];
+
+var expected4: Array<i32> = [0, 1, 2, 3];
+
+var revesed64    = createReverseOrderedArray(64);
+var revesed128   = createReverseOrderedArray(128);
+var revesed1024  = createReverseOrderedArray(1024);
+var revesed10000 = createReverseOrderedArray(10000);
+
+var randomized512 = createRandomOrderedArray(512);
+
+// Test sorting with with default comparator
+
+assertSortedDefault<i32>(revesed0);
+
+assertSortedDefault<i32>(revesed1);
+assert(isArraysEqual<i32>(revesed1, <i32[]>[1]));
+
+assertSortedDefault<i32>(revesed2);
+assert(isArraysEqual<i32>(revesed2, <i32[]>[1, 2]));
+
+assertSortedDefault<i32>(revesed4);
+assert(isArraysEqual<i32>(revesed4, expected4));
+
+assertSortedDefault<i32>(revesed64);
+assert(isArraysEqual<i32>(revesed64, expected4, 4));
+
+assertSortedDefault<i32>(revesed128);
+assert(isArraysEqual<i32>(revesed128, expected4, 4));
+
+assertSortedDefault<i32>(revesed1024);
+assert(isArraysEqual<i32>(revesed1024, expected4, 4));
+
+assertSortedDefault<i32>(revesed10000);
+assert(isArraysEqual<i32>(revesed10000, expected4, 4));
+
+assertSortedDefault<i32>(randomized512);
+
+// Test sorting with custom comparator
+
+var randomized64  = createRandomOrderedArray(64);
+var randomized257 = createRandomOrderedArray(257);
+
+assertSorted<i32>(randomized64, (a: i32, b: i32): i32 => a - b);
+assertSorted<i32>(randomized64, (a: i32, b: i32): i32 => b - a);
+
+assertSorted<i32>(randomized257, (a: i32, b: i32): i32 => a - b);
+assertSorted<i32>(randomized257, (a: i32, b: i32): i32 => b - a);
+
+// Test sorting complex objects
+
+// var reversedNested512 = createReverseOrderedNestedArray(512);
+// assertSorted<i32[]>(reversedNested512, (a: i32[], b: i32[]): i32 => a[0] - b[0]);
+
+// Test sorting reference elements
+// var reversedElements512 = createReverseOrderedElementsArray(512);
+// assertSorted<Proxy<i32>>(reversedElements512, (a: Proxy<i32>, b: Proxy<i32>): i32 => a.x - b.x);

tests/compiler/std/static-array.optimized.wat

@@ -2024,7 +2024,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)
@@ -2160,7 +2160,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)

tests/compiler/std/static-array.untouched.wat

@@ -2322,7 +2322,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)
@@ -2469,7 +2469,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)
@@ -2616,7 +2616,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)
@@ -2763,7 +2763,7 @@
     (call $abort
      (i32.const 0)
      (i32.const 160)
-     (i32.const 8)
+     (i32.const 9)
      (i32.const 4)
     )
     (unreachable)