TypeScriptToLua · GlassBricks · Aug 29, 2021 · Aug 30, 2021 · Aug 31, 2021 · Aug 31, 2021
diff --git a/benchmark/src/runtime_benchmarks/array_concat_array.ts b/benchmark/src/runtime_benchmarks/array_concat_array.ts
@@ -0,0 +1,9 @@
+export default function arrayConcat(): number[] {
+    const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+    const arr2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+    const n = 50000;
+    for (let i = 0; i < n; i++) {
+        arr1.concat(arr2);
+    }
+    return arr1;
+}
diff --git a/benchmark/src/runtime_benchmarks/array_concat_spread.ts b/benchmark/src/runtime_benchmarks/array_concat_spread.ts
@@ -0,0 +1,9 @@
+export default function arrayConcat(): number[] {
+    const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+    const arr2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+    const n = 50000;
+    for (let i = 0; i < n; i++) {
+        arr1.concat(...arr2);
+    }
+    return arr1;
+}
diff --git a/benchmark/src/runtime_benchmarks/array_every.ts b/benchmark/src/runtime_benchmarks/array_every.ts
@@ -0,0 +1,7 @@
+export default function arrayEvery() {
+    const n = 200000;
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 7, 10];
+    for (let i = 0; i < n; i++) {
+        array.every((item, index) => item > index);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_filter.ts b/benchmark/src/runtime_benchmarks/array_filter.ts
@@ -0,0 +1,7 @@
+export default function arrayFilter() {
+    const n = 100000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 7, 10];
+    for (let i = 0; i < n; i++) {
+        array.filter((item, index) => item > index);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_find.ts b/benchmark/src/runtime_benchmarks/array_find.ts
@@ -0,0 +1,9 @@
+export default function arrayFind() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 10; j++) {
+            array.find(value => value === j);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_findIndex.ts b/benchmark/src/runtime_benchmarks/array_findIndex.ts
@@ -0,0 +1,9 @@
+export default function arrayFindIndex() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 10; j++) {
+            array.findIndex(value => value === j);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_flat.ts b/benchmark/src/runtime_benchmarks/array_flat.ts
@@ -0,0 +1,7 @@
+export default function arrayFlat() {
+    const n = 50000;
+    const array = [1, 2, [3, [4, 5], 6], 7, [8, 9], 10];
+    for (let i = 0; i < n; i++) {
+        array.flat(2);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_flatMap.ts b/benchmark/src/runtime_benchmarks/array_flatMap.ts
@@ -0,0 +1,13 @@
+export default function arrayFlatMap() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        array.flatMap((el, index) => {
+            if (index < 5) {
+                return [el, el + 1];
+            } else {
+                return el + 2;
+            }
+        });
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_foreach.ts b/benchmark/src/runtime_benchmarks/array_foreach.ts
@@ -0,0 +1,10 @@
+export default function arrayForeach() {
+    const n = 200000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        array.forEach(value => {
+            let foo = value * 2;
+            foo = foo;
+        });
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_includes.ts b/benchmark/src/runtime_benchmarks/array_includes.ts
@@ -0,0 +1,9 @@
+export default function arrayIncludes() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 10; j++) {
+            array.includes(j);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_indexOf.ts b/benchmark/src/runtime_benchmarks/array_indexOf.ts
@@ -0,0 +1,9 @@
+export default function arrayIndexOf() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 10; j++) {
+            array.indexOf(j);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_join.ts b/benchmark/src/runtime_benchmarks/array_join.ts
@@ -0,0 +1,17 @@
+const array = [1, 2, "3", 4, 3, "6", { foo: 3 }, 8, 9, 10];
+
+const k = 500;
+for (let i = 0; i < k; i++) {
+    if (i % 2 === 0) {
+        array[i] = i.toString();
+    } else {
+        array[i] = i % 3;
+    }
+}
+
+export default function arrayJoin() {
+    const n = 3000;
+    for (let i = 0; i < n; i++) {
+        array.join("|");
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_map.ts b/benchmark/src/runtime_benchmarks/array_map.ts
@@ -0,0 +1,7 @@
+export default function arrayMap() {
+    const n = 100000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        array.map(value => value * 2);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_push_array.ts b/benchmark/src/runtime_benchmarks/array_push_array.ts
@@ -0,0 +1,9 @@
+export default function arrayPush(): number[] {
+    const n = 200000;
+    const numberList: number[] = [];
+    const numbers = [1, 2, 3];
+    for (let i = 0; i < n; i++) {
+        numberList.push(...numbers);
+    }
+    return numberList;
+}
diff --git a/...mark/src/runtime_benchmarks/array_push.ts → ...runtime_benchmarks/array_push_multiple.ts b/...mark/src/runtime_benchmarks/array_push.ts → ...runtime_benchmarks/array_push_multiple.ts
@@ -1,8 +1,8 @@
 export default function arrayPush(): number[] {
-    const n = 1000000;
+    const n = 200000;
     const numberList: number[] = [];
     for (let i = 0; i < n; i++) {
-        numberList[numberList.length] = i * i;
+        numberList.push(i * i, i + 1);
     }
     return numberList;
 }
diff --git a/benchmark/src/runtime_benchmarks/array_push_single.ts b/benchmark/src/runtime_benchmarks/array_push_single.ts
@@ -0,0 +1,8 @@
+export default function arrayPush(): number[] {
+    const n = 500000;
+    const numberList: number[] = [];
+    for (let i = 0; i < n; i++) {
+        numberList.push(i * i);
+    }
+    return numberList;
+}
diff --git a/benchmark/src/runtime_benchmarks/array_reduce.ts b/benchmark/src/runtime_benchmarks/array_reduce.ts
@@ -0,0 +1,7 @@
+export default function arrayReduce() {
+    const n = 200000;
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 7, 10];
+    for (let i = 0; i < n; i++) {
+        array.reduce((prev, cur, i) => prev + cur + i, 1);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_reduceRight.ts b/benchmark/src/runtime_benchmarks/array_reduceRight.ts
@@ -0,0 +1,7 @@
+export default function arrayReduce() {
+    const n = 200000;
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 7, 10];
+    for (let i = 0; i < n; i++) {
+        array.reduceRight((prev, cur, i) => prev + cur + i, 1);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_reverse.ts b/benchmark/src/runtime_benchmarks/array_reverse.ts
@@ -0,0 +1,7 @@
+export default function arrayReverse(): void {
+    const n = 500000;
+    const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        numbers.reverse();
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_slice.ts b/benchmark/src/runtime_benchmarks/array_slice.ts
@@ -0,0 +1,9 @@
+export default function arraySlice() {
+    const n = 50000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 6; j++) {
+            array.slice(j, -j);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_some.ts b/benchmark/src/runtime_benchmarks/array_some.ts
@@ -0,0 +1,7 @@
+export default function arraySome() {
+    const n = 200000;
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 7, 10];
+    for (let i = 0; i < n; i++) {
+        array.some((item, index) => item < index);
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_splice.ts b/benchmark/src/runtime_benchmarks/array_splice.ts
@@ -0,0 +1,9 @@
+export default function arraySplice() {
+    const n = 20000;
+    const array = [1, 2, 3, 4, 3, 6, 7, 8, 9, 10];
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 10; j++) {
+            array.splice(j, 2, 1, 2);
+        }
+    }
+}
diff --git a/benchmark/src/runtime_benchmarks/array_unshift.ts b/benchmark/src/runtime_benchmarks/array_unshift.ts
@@ -0,0 +1,9 @@
+export default function arrayUnshift(): number[] {
+    const n = 2000;
+    const numberList: number[] = [];
+    const numbers = [1, 2, 3];
+    for (let i = 0; i < n; i++) {
+        numberList.unshift(...numbers);
+    }
+    return numberList;
+}
diff --git a/src/LuaAST.ts b/src/LuaAST.ts
@@ -86,6 +86,14 @@ export enum SyntaxKind {
     BitwiseNotOperator, // Unary
 }
 
+export enum NodeFlags {
+    None = 0,
+    Inline = 1 << 0, // Keep function body on same line
+    Declaration = 1 << 1, // Prefer declaration syntax `function foo()` over assignment syntax `foo = function()`
+    PossiblyNotUsed = 1 << 2, // for an expression, if in an ExpressionStatement, statement is not emitted
+    IsUnpackCall = 1 << 3,
+}
+
 // TODO maybe name this PrefixUnary? not sure it makes sense to do so, because all unary ops in Lua are prefix
 export type UnaryBitwiseOperator = SyntaxKind.BitwiseNotOperator;
 
@@ -132,25 +140,36 @@ export interface TextRange {
 
 export interface Node extends TextRange {
     kind: SyntaxKind;
+    flags: NodeFlags;
 }
 
-export function createNode(kind: SyntaxKind, tsOriginal?: ts.Node): Node {
+export function createNode(kind: SyntaxKind, tsOriginal?: ts.Node, flags: NodeFlags = NodeFlags.None): Node {
     if (tsOriginal === undefined) {
-        return { kind };
+        return { kind, flags };
     }
 
     const sourcePosition = getSourcePosition(tsOriginal);
     if (sourcePosition) {
-        return { kind, line: sourcePosition.line, column: sourcePosition.column };
+        return { kind, flags, line: sourcePosition.line, column: sourcePosition.column };
     } else {
-        return { kind };
+        return { kind, flags };
     }
 }
 
 export function cloneNode<T extends Node>(node: T): T {
     return { ...node };
 }
 
+export function setNodeFlags<T extends Node>(node: T, flags: NodeFlags): T {
+    node.flags = flags;
+    return node;
+}
+
+export function addNodeFlags<T extends Node>(node: T, flags: NodeFlags): T {
+    node.flags |= flags;
+    return node;
+}
+
 export function setNodePosition<T extends Node>(node: T, position: TextRange): T {
     node.line = position.line;
     node.column = position.column;
@@ -566,18 +585,23 @@ export function createStringLiteral(value: string, tsOriginal?: ts.Node): String
     return expression;
 }
 
-export enum FunctionExpressionFlags {
-    None = 1 << 0,
-    Inline = 1 << 1, // Keep function body on same line
-    Declaration = 1 << 2, // Prefer declaration syntax `function foo()` over assignment syntax `foo = function()`
+export function isLiteral(
+    node: Node
+): node is NilLiteral | DotsLiteral | BooleanLiteral | NumericLiteral | StringLiteral {
+    return (
+        isNilLiteral(node) ||
+        isDotsLiteral(node) ||
+        isBooleanLiteral(node) ||
+        isNumericLiteral(node) ||
+        isStringLiteral(node)
+    );
 }
 
 export interface FunctionExpression extends Expression {
     kind: SyntaxKind.FunctionExpression;
     params?: Identifier[];
     dots?: DotsLiteral;
     body: Block;
-    flags: FunctionExpressionFlags;
 }
 
 export function isFunctionExpression(node: Node): node is FunctionExpression {
@@ -588,14 +612,13 @@ export function createFunctionExpression(
     body: Block,
     params?: Identifier[],
     dots?: DotsLiteral,
-    flags = FunctionExpressionFlags.None,
+    flags = NodeFlags.None,
     tsOriginal?: ts.Node
 ): FunctionExpression {
-    const expression = createNode(SyntaxKind.FunctionExpression, tsOriginal) as FunctionExpression;
+    const expression = createNode(SyntaxKind.FunctionExpression, tsOriginal, flags) as FunctionExpression;
     expression.body = body;
     expression.params = params;
     expression.dots = dots;
-    expression.flags = flags;
     return expression;
 }
 
@@ -807,6 +830,6 @@ export function isInlineFunctionExpression(expression: FunctionExpression): expr
         expression.body.statements?.length === 1 &&
         isReturnStatement(expression.body.statements[0]) &&
         expression.body.statements[0].expressions !== undefined &&
-        (expression.flags & FunctionExpressionFlags.Inline) !== 0
+        (expression.flags & NodeFlags.Inline) !== 0
     );
 }