Merge remote-tracking branch 'upstream/master' into out-file

hazzard993 · hazzard993 · commit 2d164c205571 · 2019-10-07T11:08:25.000+10:00
diff --git a/src/LuaLib.ts b/src/LuaLib.ts
@@ -6,6 +6,7 @@ export enum LuaLibFeature {
     ArrayEvery = "ArrayEvery",
     ArrayFilter = "ArrayFilter",
     ArrayForEach = "ArrayForEach",
+    ArrayFind = "ArrayFind",
     ArrayFindIndex = "ArrayFindIndex",
     ArrayIndexOf = "ArrayIndexOf",
     ArrayMap = "ArrayMap",
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -5148,6 +5148,8 @@ export class LuaTransformer {
                 );
             case "forEach":
                 return this.transformLuaLibFunction(LuaLibFeature.ArrayForEach, node, caller, ...params);
+            case "find":
+                return this.transformLuaLibFunction(LuaLibFeature.ArrayFind, node, caller, ...params);
             case "findIndex":
                 return this.transformLuaLibFunction(LuaLibFeature.ArrayFindIndex, node, caller, ...params);
             case "indexOf":
diff --git a/src/lualib/ArrayFind.ts b/src/lualib/ArrayFind.ts
@@ -0,0 +1,18 @@
+// https://www.ecma-international.org/ecma-262/10.0/index.html#sec-array.prototype.find
+function __TS__ArrayFind<T>(
+    this: void,
+    arr: T[],
+    predicate: (value: T, index: number, obj: T[]) => unknown
+): T | undefined {
+    const len = arr.length;
+    let k = 0;
+    while (k < len) {
+        const elem = arr[k];
+        if (predicate(elem, k, arr)) {
+            return elem;
+        }
+        k = k + 1;
+    }
+
+    return undefined;
+}
diff --git a/src/lualib/ArrayReduce.ts b/src/lualib/ArrayReduce.ts
@@ -3,25 +3,26 @@ function __TS__ArrayReduce<T>(
     this: void,
     arr: T[],
     callbackFn: (accumulator: T, currentValue: T, index: number, array: T[]) => T,
-    initial?: T
+    ...initial: Vararg<T>
 ): T {
     const len = arr.length;
 
-    if (len === 0 && initial === undefined) {
-        // tslint:disable-next-line: no-string-throw
-        throw "Reduce of empty array with no initial value";
-    }
-
     let k = 0;
-    let accumulator = initial;
-    if (initial === undefined) {
+    let accumulator = undefined;
+
+    // Check if initial value is present in function call
+    if (select("#", ...initial) !== 0) {
+        accumulator = select(1, ...initial);
+    } else if (len > 0) {
         accumulator = arr[0];
-        k++;
+        k = 1;
+    } else {
+        // tslint:disable-next-line: no-string-throw
+        throw "Reduce of empty array with no initial value";
     }
 
-    while (k < len) {
-        accumulator = callbackFn(accumulator, arr[k], k, arr);
-        k = k + 1;
+    for (const i of forRange(k, len - 1)) {
+        accumulator = callbackFn(accumulator, arr[i], i, arr);
     }
 
     return accumulator;
diff --git a/src/lualib/declarations/global.d.ts b/src/lualib/declarations/global.d.ts
@@ -16,3 +16,6 @@ declare function rawset<T, K extends keyof T>(table: T, key: K, val: T[K]): void
 declare function next<K, V>(table: Record<any, V>, index?: K): [K, V];
 declare function pcall(func: () => any): any;
 declare function unpack<T>(list: T[], i?: number, j?: number): T[];
+
+declare function select<T>(index: number, ...args: T[]): T;
+declare function select<T>(index: "#", ...args: T[]): number;
diff --git a/src/lualib/declarations/tstl.d.ts b/src/lualib/declarations/tstl.d.ts
@@ -1,5 +1,11 @@
 /** @noSelfInFile */
 
+/** @vararg */
+interface Vararg<T> extends Array<T> {}
+
+/** @forRange */
+declare function forRange(start: number, limit: number, step?: number): number[];
+
 interface LuaClass {
     prototype: LuaObject;
     ____super?: LuaClass;
diff --git a/test/unit/builtins/array.spec.ts b/test/unit/builtins/array.spec.ts
@@ -246,9 +246,25 @@ test("array.forEach (%p)", () => {
     `.expectToMatchJsResult();
 });
 
+test.each([
+    { array: [], predicate: "elem > 3" },
+    { array: [0, 2, 4, 8], predicate: "elem > 10" },
+    { array: [0, 2, 4, 8], predicate: "elem > 7" },
+    { array: [0, 2, 4, 8], predicate: "elem == 0" },
+    { array: [0, 2, 4, 8], predicate: "elem > 7" },
+    { array: [0, 2, 4, 8], predicate: "true" },
+    { array: [0, 2, 4, 8], predicate: "false" },
+])("array.find (%p)", ({ array, predicate }) => {
+    util.testFunction`
+        const array = ${util.valueToString(array)};
+        return array.find((elem, index, arr) => ${predicate} && arr[index] === elem);
+    `.expectToMatchJsResult();
+});
+
 test.each([
     { array: [], searchElement: 3 },
     { array: [0, 2, 4, 8], searchElement: 10 },
+    { array: [0, 2, 4, 8], searchElement: 0 },
     { array: [0, 2, 4, 8], searchElement: 8 },
 ])("array.findIndex (%p)", ({ array, searchElement }) => {
     util.testFunction`
@@ -486,6 +502,22 @@ test.each<[[(total: number, currentItem: number, index: number, array: number[])
     util.testExpression`[1, 3, 5, 7].reduce(${util.valuesToString(args)})`.expectToMatchJsResult();
 });
 
+test("array.reduce empty undefined initial", () => {
+    util.testExpression`[].reduce(() => {}, undefined)`.expectToMatchJsResult();
+});
+
+test("array.reduce empty no initial", () => {
+    util.testExpression`[].reduce(() => {})`.expectToMatchJsResult(true);
+});
+
+test("array.reduce undefined returning callback", () => {
+    util.testFunction`
+        const calls: Array<{ a: void, b: string }> = [];
+        ["a", "b"].reduce<void>((a, b) => { calls.push({ a, b }) }, undefined);
+        return calls;
+    `.expectToMatchJsResult();
+});
+
 const genericChecks = [
     "function generic<T extends number[]>(array: T)",
     "function generic<T extends [...number[]]>(array: T)",
