TypeScriptToLua · Perryvw · Jul 18, 2022 · Jul 13, 2022 · Jul 14, 2022 · Jul 14, 2022
diff --git a/.gitignore b/.gitignore
@@ -9,3 +9,7 @@ yarn.lock
 
 benchmark/data/*
 benchmark/dist/*
+
+# v8 cpu profiles
+*-.log
+*.cpuprofile
diff --git a/language-extensions/index.d.ts b/language-extensions/index.d.ts
diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -37,6 +37,7 @@ export interface TypeScriptToLuaOptions {
     sourceMapTraceback?: boolean;
     tstlVerbose?: boolean;
     lua51AllowTryCatchInAsyncAwait?: boolean;
+    measurePerformance?: boolean;
 }
 
 export type CompilerOptions = OmitIndexSignature<ts.CompilerOptions> &

diff --git a/src/cli/parse.ts b/src/cli/parse.ts
@@ -99,6 +99,11 @@ export const optionDeclarations: CommandLineOption[] = [
         description: "Always allow try/catch in async/await functions for Lua 5.1.",
         type: "boolean",
     },
+    {
+        name: "measurePerformance",
+        description: "Measure performance of the tstl compiler.",
+        type: "boolean",
+    },
 ];
 
 export function updateParsedConfigFile(parsedConfigFile: ts.ParsedCommandLine): ParsedCommandLine {

diff --git a/src/lualib-build/plugin.ts b/src/lualib-build/plugin.ts
@@ -2,7 +2,6 @@ import { SourceNode } from "source-map";
 import * as ts from "typescript";
 import * as tstl from "..";
 import * as path from "path";
-import { getUsedLuaLibFeatures } from "../transformation/utils/lualib";
 import { LuaLibFeature, LuaLibModulesInfo, luaLibModulesInfoFileName, resolveRecursiveLualibFeatures } from "../LuaLib";
 import { EmitHost, ProcessedFile } from "../transpilation/utils";
 import {
@@ -72,7 +71,7 @@ class LuaLibPlugin implements tstl.Plugin {
         // Transpile file as normal with tstl
         const fileResult = context.superTransformNode(file)[0] as tstl.File;
 
-        const usedFeatures = new Set<tstl.LuaLibFeature>(getUsedLuaLibFeatures(context));
+        const usedFeatures = new Set<tstl.LuaLibFeature>(context.usedLuaLibFeatures);
 
         // Get all imports in file
         const importNames = new Set<string>();

diff --git a/src/measure-performance.ts b/src/measure-performance.ts
@@ -0,0 +1,83 @@
+import { performance } from "perf_hooks";
+
+// We use our own performance hooks implementation for easier use, but also call node's performance hooks, so it shows up in the profiler.
+
+let enabled = false;
+const marks = new Map<string, number>();
+const durations = new Map<string, number>();
+
+function timestamp() {
+    return performance.now();
+}
+
+/**
+ * Marks a performance event, with the given markName.
+ */
+function mark(markName: string) {
+    if (enabled) {
+        marks.set(markName, timestamp());
+        performance.mark(markName);
+    }
+}
+
+/**
+ * Adds a performance measurement with the specified name.
+ *
+ * @param measureName The name of the performance measurement.
+ * @param startMarkName The name of the starting mark
+ * @param endMarkName The name of the ending mark
+ */
+function measure(measureName: string, startMarkName: string, endMarkName: string) {
+    if (enabled) {
+        const end = marks.get(endMarkName) ?? timestamp();
+        const start = marks.get(startMarkName) ?? performance.timeOrigin;
+        const previousDuration = durations.get(measureName) ?? 0;
+        durations.set(measureName, previousDuration + (end - start));
+        performance.measure(measureName, startMarkName, endMarkName);
+    }
+}
+
+/**
+ * Starts a performance measurement section.
+ * @param name name of the measurement
+ */
+export function startSection(name: string) {
+    mark("start " + name);
+}
+
+/**
+ * Ends a performance measurement section.
+ * @param name name of the measurement
+ */
+export function endSection(name: string) {
+    mark("end " + name);
+    measure(name, "start " + name, "end " + name);
+}
+
+export function isMeasurementEnabled() {
+    return enabled;
+}
+
+export function enableMeasurement() {
+    if (!enabled) {
+        enabled = true;
+    }
+}
+
+export function disableMeasurement() {
+    if (enabled) {
+        enabled = false;
+        marks.clear();
+        durations.clear();
+    }
+}
+
+export function forEachMeasure(callback: (measureName: string, duration: number) => void) {
+    durations.forEach((duration, measureName) => callback(measureName, duration));
+}
+
+export function getTotalDuration() {
+    let total = 0;
+    forEachMeasure((_, duration) => (total += duration));
+    return total;
+}
diff --git a/src/transformation/builtins/array.ts b/src/transformation/builtins/array.ts
@@ -4,7 +4,7 @@ import { TransformationContext } from "../context";
 import { unsupportedProperty } from "../utils/diagnostics";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { transformArguments, transformCallAndArguments } from "../visitors/call";
-import { isStringType, isNumberType, findFirstNonOuterParent } from "../utils/typescript";
+import { findFirstNonOuterParent, typeAlwaysHasSomeOfFlags } from "../utils/typescript";
 import { moveToPrecedingTemp } from "../visitors/expression-list";
 import { isUnpackCall, wrapInTable } from "../utils/lua-ast";
 
@@ -145,7 +145,10 @@ export function transformArrayPrototypeCall(
         case "join":
             const callerType = context.checker.getTypeAtLocation(calledMethod.expression);
             const elementType = context.checker.getElementTypeOfArrayType(callerType);
-            if (elementType && (isStringType(context, elementType) || isNumberType(context, elementType))) {
+            if (
+                elementType &&
+                typeAlwaysHasSomeOfFlags(context, elementType, ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike)
+            ) {
                 const defaultSeparatorLiteral = lua.createStringLiteral(",");
                 const param = params[0];
                 const parameters = [

diff --git a/src/transformation/builtins/global.ts b/src/transformation/builtins/global.ts
@@ -5,24 +5,27 @@ import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { isNumberType } from "../utils/typescript";
 import { transformArguments } from "../visitors/call";
 
-export function transformGlobalCall(
+export function tryTransformBuiltinGlobalCall(
     context: TransformationContext,
-    node: ts.CallExpression
+    node: ts.CallExpression,
+    expressionType: ts.Type
 ): lua.Expression | undefined {
-    const signature = context.checker.getResolvedSignature(node);
-    const parameters = transformArguments(context, node.arguments, signature);
-    const expressionType = context.checker.getTypeAtLocation(node.expression);
+    function getParameters() {
+        const signature = context.checker.getResolvedSignature(node);
+        return transformArguments(context, node.arguments, signature);
+    }
+
     const name = expressionType.symbol.name;
     switch (name) {
         case "SymbolConstructor":
-            return transformLuaLibFunction(context, LuaLibFeature.Symbol, node, ...parameters);
+            return transformLuaLibFunction(context, LuaLibFeature.Symbol, node, ...getParameters());
         case "NumberConstructor":
-            return transformLuaLibFunction(context, LuaLibFeature.Number, node, ...parameters);
+            return transformLuaLibFunction(context, LuaLibFeature.Number, node, ...getParameters());
         case "isNaN":
         case "isFinite":
             const numberParameters = isNumberType(context, expressionType)
-                ? parameters
-                : [transformLuaLibFunction(context, LuaLibFeature.Number, undefined, ...parameters)];
+                ? getParameters()
+                : [transformLuaLibFunction(context, LuaLibFeature.Number, undefined, ...getParameters())];
 
             return transformLuaLibFunction(
                 context,
@@ -31,8 +34,8 @@ export function transformGlobalCall(
                 ...numberParameters
             );
         case "parseFloat":
-            return transformLuaLibFunction(context, LuaLibFeature.ParseFloat, node, ...parameters);
+            return transformLuaLibFunction(context, LuaLibFeature.ParseFloat, node, ...getParameters());
         case "parseInt":
-            return transformLuaLibFunction(context, LuaLibFeature.ParseInt, node, ...parameters);
+            return transformLuaLibFunction(context, LuaLibFeature.ParseInt, node, ...getParameters());
     }
 }