typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/visitors/namespace.js

@@ -13,11 +13,11 @@ const symbols_1 = require("../utils/symbols");
 const identifier_1 = require("./identifier");
 function createModuleLocalNameIdentifier(context, declaration) {
     const moduleSymbol = context.checker.getSymbolAtLocation(declaration.name);
-    if (moduleSymbol !== undefined && safe_names_1.isUnsafeName(moduleSymbol.name)) {
-        return lua.createIdentifier(safe_names_1.createSafeName(declaration.name.text), declaration.name, moduleSymbol && symbols_1.getSymbolIdOfSymbol(context, moduleSymbol), declaration.name.text);
+    if (moduleSymbol !== undefined && (0, safe_names_1.isUnsafeName)(moduleSymbol.name)) {
+        return lua.createIdentifier((0, safe_names_1.createSafeName)(declaration.name.text), declaration.name, moduleSymbol && (0, symbols_1.getSymbolIdOfSymbol)(context, moduleSymbol), declaration.name.text);
     }
     // TODO: Should synthetic name nodes be escaped as well?
-    return identifier_1.transformIdentifier(context, declaration.name);
+    return (0, identifier_1.transformIdentifier)(context, declaration.name);
 }
 exports.createModuleLocalNameIdentifier = createModuleLocalNameIdentifier;
 // TODO: Do it based on transform result?
@@ -37,17 +37,17 @@ function moduleHasEmittedBody(node) {
 const currentNamespaces = new WeakMap();
 const transformModuleDeclaration = (node, context) => {
     var _a, _b;
-    const annotations = annotations_1.getTypeAnnotations(context.checker.getTypeAtLocation(node));
+    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(node));
     // If phantom namespace elide the declaration and return the body
     if (annotations.has(annotations_1.AnnotationKind.Phantom)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.Phantom));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Phantom));
     }
     const currentNamespace = currentNamespaces.get(context);
     const result = [];
     const symbol = context.checker.getSymbolAtLocation(node.name);
     const hasExports = symbol !== undefined && context.checker.getExportsOfModule(symbol).length > 0;
-    const nameIdentifier = identifier_1.transformIdentifier(context, node.name);
-    const exportScope = export_1.getIdentifierExportScope(context, nameIdentifier);
+    const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
+    const exportScope = (0, export_1.getIdentifierExportScope)(context, nameIdentifier);
     // Non-module namespace could be merged if:
     // - is top level
     // - is nested and exported
@@ -60,17 +60,17 @@ const transformModuleDeclaration = (node, context) => {
             ts.getOriginalNode(node) === ((_b = symbol.declarations) === null || _b === void 0 ? void 0 : _b.find(ts.isModuleDeclaration)));
     if (isNonModuleMergeable) {
         // 'local NS = NS or {}' or 'exportTable.NS = exportTable.NS or {}'
-        const localDeclaration = lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, nameIdentifier, lua.createBinaryExpression(export_1.addExportToIdentifier(context, nameIdentifier), lua.createTableExpression(), lua.SyntaxKind.OrOperator));
+        const localDeclaration = (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, nameIdentifier, lua.createBinaryExpression((0, export_1.addExportToIdentifier)(context, nameIdentifier), lua.createTableExpression(), lua.SyntaxKind.OrOperator));
         result.push(...localDeclaration);
     }
     else if (isFirstDeclaration) {
         // local NS = {} or exportTable.NS = {}
-        const localDeclaration = lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, nameIdentifier, lua.createTableExpression());
+        const localDeclaration = (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, nameIdentifier, lua.createTableExpression());
         result.push(...localDeclaration);
     }
     if ((isNonModuleMergeable || isFirstDeclaration) && exportScope && hasExports && moduleHasEmittedBody(node)) {
         // local NS = exportTable.NS
-        const localDeclaration = lua_ast_1.createHoistableVariableDeclarationStatement(context, createModuleLocalNameIdentifier(context, node), export_1.createExportedIdentifier(context, nameIdentifier, exportScope));
+        const localDeclaration = (0, lua_ast_1.createHoistableVariableDeclarationStatement)(context, createModuleLocalNameIdentifier(context, node), (0, export_1.createExportedIdentifier)(context, nameIdentifier, exportScope));
         result.push(localDeclaration);
     }
     // Set current namespace for nested NS
@@ -78,9 +78,9 @@ const transformModuleDeclaration = (node, context) => {
     currentNamespaces.set(context, node);
     // Transform moduleblock to block and visit it
     if (moduleHasEmittedBody(node)) {
-        scope_1.pushScope(context, scope_1.ScopeType.Block);
-        const statements = scope_1.performHoisting(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
-        scope_1.popScope(context);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+        const statements = (0, scope_1.performHoisting)(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
+        (0, scope_1.popScope)(context);
         result.push(lua.createDoStatement(statements));
     }
     currentNamespaces.set(context, currentNamespace);

package/dist/transformation/visitors/optional-chaining.d.ts

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+export interface ExpressionWithThisValue {
+    expression: lua.Expression;
+    thisValue?: lua.Expression;
+}
+export declare function captureThisValue(context: TransformationContext, expression: lua.Expression, thisValueCapture: lua.Identifier, tsOriginal: ts.Node): lua.Expression;
+export interface OptionalContinuation {
+    contextualCall?: lua.CallExpression;
+}
+export declare function isOptionalContinuation(node: ts.Node): boolean;
+export declare function getOptionalContinuationData(identifier: ts.Identifier): OptionalContinuation | undefined;
+export declare function transformOptionalChain(context: TransformationContext, node: ts.OptionalChain): lua.Expression;
+export declare function transformOptionalChainWithCapture(context: TransformationContext, node: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
+export declare function transformOptionalDeleteExpression(context: TransformationContext, node: ts.DeleteExpression, innerExpression: ts.OptionalChain): lua.BooleanLiteral;

package/dist/transformation/visitors/optional-chaining.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOptionalDeleteExpression = exports.transformOptionalChainWithCapture = exports.transformOptionalChain = exports.getOptionalContinuationData = exports.isOptionalContinuation = exports.captureThisValue = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const utils_1 = require("../../utils");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const access_1 = require("./access");
+const expression_list_1 = require("./expression-list");
+function skipNonNullChains(chain) {
+    while (ts.isNonNullChain(chain)) {
+        chain = chain.expression;
+    }
+    return chain;
+}
+function flattenChain(chain) {
+    chain = skipNonNullChains(chain);
+    const links = [chain];
+    while (!chain.questionDotToken && !ts.isTaggedTemplateExpression(chain)) {
+        const nextLink = chain.expression;
+        (0, utils_1.assert)(ts.isOptionalChain(nextLink));
+        chain = skipNonNullChains(nextLink);
+        links.unshift(chain);
+    }
+    return { expression: chain.expression, chain: links };
+}
+function transformExpressionWithThisValueCapture(context, node, thisValueCapture) {
+    if (ts.isParenthesizedExpression(node)) {
+        return transformExpressionWithThisValueCapture(context, node.expression, thisValueCapture);
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return (0, access_1.transformPropertyAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    if (ts.isElementAccessExpression(node)) {
+        return (0, access_1.transformElementAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    return { expression: context.transformExpression(node) };
+}
+// returns thisValueCapture exactly if a temp variable was used.
+function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+        return expression;
+    }
+    const tempAssignment = lua.createAssignmentStatement(thisValueCapture, expression, tsOriginal);
+    context.addPrecedingStatements(tempAssignment);
+    return thisValueCapture;
+}
+exports.captureThisValue = captureThisValue;
+const optionalContinuations = new WeakMap();
+// should be translated verbatim to lua
+function createOptionalContinuationIdentifier(text, tsOriginal) {
+    const identifier = ts.factory.createIdentifier(text);
+    ts.setOriginalNode(identifier, tsOriginal);
+    optionalContinuations.set(identifier, {});
+    return identifier;
+}
+function isOptionalContinuation(node) {
+    return ts.isIdentifier(node) && optionalContinuations.has(node);
+}
+exports.isOptionalContinuation = isOptionalContinuation;
+function getOptionalContinuationData(identifier) {
+    return optionalContinuations.get(identifier);
+}
+exports.getOptionalContinuationData = getOptionalContinuationData;
+function transformOptionalChain(context, node) {
+    return transformOptionalChainWithCapture(context, node, undefined).expression;
+}
+exports.transformOptionalChain = transformOptionalChain;
+function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
+    var _a;
+    const luaTemp = context.createTempNameForNode(node);
+    const { expression: tsLeftExpression, chain } = flattenChain(node);
+    // build temp.b.c.d
+    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    let tsRightExpression = tsTemp;
+    for (const link of chain) {
+        if (ts.isPropertyAccessExpression(link)) {
+            tsRightExpression = ts.factory.createPropertyAccessExpression(tsRightExpression, link.name);
+        }
+        else if (ts.isElementAccessExpression(link)) {
+            tsRightExpression = ts.factory.createElementAccessExpression(tsRightExpression, link.argumentExpression);
+        }
+        else if (ts.isCallExpression(link)) {
+            tsRightExpression = ts.factory.createCallExpression(tsRightExpression, undefined, link.arguments);
+        }
+        else {
+            (0, utils_1.assertNever)(link);
+        }
+        ts.setOriginalNode(tsRightExpression, link);
+    }
+    if (isDelete) {
+        tsRightExpression = ts.factory.createDeleteExpression(tsRightExpression);
+        ts.setOriginalNode(tsRightExpression, isDelete);
+    }
+    // transform right expression first to check if thisValue capture is needed
+    // capture and return thisValue if requested from outside
+    let returnThisValue;
+    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (thisValueCapture) {
+            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
+        }
+        else {
+            result = context.transformExpression(tsRightExpression);
+        }
+        return lua.createAssignmentStatement(luaTemp, result);
+    });
+    // transform left expression, handle thisValue if needed by rightExpression
+    const thisValueCaptureName = context.createTempName("this");
+    const leftThisValueTemp = lua.createIdentifier(thisValueCaptureName, undefined, context_1.tempSymbolId);
+    let capturedThisValue;
+    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
+    const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (rightContextualCall) {
+            ({ expression: result, thisValue: capturedThisValue } = transformExpressionWithThisValueCapture(context, tsLeftExpression, leftThisValueTemp));
+        }
+        else {
+            result = context.transformExpression(tsLeftExpression);
+        }
+        return result;
+    });
+    // handle context
+    if (rightContextualCall) {
+        if (capturedThisValue) {
+            rightContextualCall.params[0] = capturedThisValue;
+            if (capturedThisValue === leftThisValueTemp) {
+                context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftThisValueTemp));
+            }
+        }
+        else {
+            if (context.isStrict) {
+                rightContextualCall.params[0] = lua.createNilLiteral();
+            }
+            else {
+                const identifier = lua.createIdentifier("_G");
+                if (rightPrecedingStatements.length === 0) {
+                    rightContextualCall.params[0] = identifier;
+                }
+                else {
+                    const tempContext = context.createTempNameForLuaExpression(identifier);
+                    rightPrecedingStatements.unshift(lua.createVariableDeclarationStatement(tempContext, identifier));
+                    rightContextualCall.params[0] = tempContext;
+                }
+            }
+        }
+    }
+    // <left preceding statements>
+    // local temp = <left>
+    // if temp ~= nil then
+    //   <right preceding statements>
+    //   temp = temp.b.c.d
+    // end
+    // return temp
+    context.addPrecedingStatements([
+        ...leftPrecedingStatements,
+        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
+        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
+    ]);
+    return {
+        expression: luaTemp,
+        thisValue: returnThisValue,
+    };
+}
+exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;
+function transformOptionalDeleteExpression(context, node, innerExpression) {
+    transformOptionalChainWithCapture(context, innerExpression, undefined, node);
+    return lua.createBooleanLiteral(true, node);
+}
+exports.transformOptionalDeleteExpression = transformOptionalDeleteExpression;
+//# sourceMappingURL=optional-chaining.js.map

package/dist/transformation/visitors/return.d.ts

@@ -3,3 +3,4 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformExpressionBodyToReturnStatement(context: TransformationContext, node: ts.Expression): lua.Statement;
 export declare const transformReturnStatement: FunctionVisitor<ts.ReturnStatement>;
+export declare function createReturnStatement(context: TransformationContext, values: lua.Expression[], node: ts.Node): lua.ReturnStatement;

package/dist/transformation/visitors/return.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReturnStatement = exports.transformExpressionBodyToReturnStatement = void 0;
+exports.createReturnStatement = exports.transformReturnStatement = exports.transformExpressionBodyToReturnStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const assignment_validation_1 = require("../utils/assignment-validation");
@@ -9,65 +9,79 @@ const scope_1 = require("../utils/scope");
 const call_1 = require("./call");
 const multi_1 = require("./language-extensions/multi");
 const diagnostics_1 = require("../utils/diagnostics");
+const typescript_1 = require("../utils/typescript");
 function transformExpressionsInReturn(context, node, insideTryCatch) {
     const expressionType = context.checker.getTypeAtLocation(node);
     if (ts.isCallExpression(node)) {
         // $multi(...)
-        if (multi_1.isMultiFunctionCall(context, node)) {
+        if ((0, multi_1.isMultiFunctionCall)(context, node)) {
             // Don't allow $multi to be implicitly cast to something other than LuaMultiReturn
             const type = context.checker.getContextualType(node);
-            if (type && !multi_1.canBeMultiReturnType(type)) {
-                context.diagnostics.push(diagnostics_1.invalidMultiFunctionReturnType(node));
+            if (type && !(0, multi_1.canBeMultiReturnType)(type)) {
+                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionReturnType)(node));
             }
-            let returnValues = call_1.transformArguments(context, node.arguments);
+            let returnValues = (0, call_1.transformArguments)(context, node.arguments);
             if (insideTryCatch) {
-                returnValues = [lua_ast_1.wrapInTable(...returnValues)]; // Wrap results when returning inside try/catch
+                returnValues = [(0, lua_ast_1.wrapInTable)(...returnValues)]; // Wrap results when returning inside try/catch
             }
             return returnValues;
         }
         // Force-wrap LuaMultiReturn when returning inside try/catch
-        if (insideTryCatch && multi_1.returnsMultiType(context, node) && !multi_1.shouldMultiReturnCallBeWrapped(context, node)) {
-            return [lua_ast_1.wrapInTable(context.transformExpression(node))];
+        if (insideTryCatch && (0, multi_1.returnsMultiType)(context, node) && !(0, multi_1.shouldMultiReturnCallBeWrapped)(context, node)) {
+            return [(0, lua_ast_1.wrapInTable)(context.transformExpression(node))];
         }
     }
-    else if (multi_1.isInMultiReturnFunction(context, node) && multi_1.isMultiReturnType(expressionType)) {
+    else if ((0, multi_1.isInMultiReturnFunction)(context, node) && (0, multi_1.isMultiReturnType)(expressionType)) {
         // Unpack objects typed as LuaMultiReturn
-        return [lua_ast_1.createUnpackCall(context, context.transformExpression(node), node)];
+        return [(0, lua_ast_1.createUnpackCall)(context, context.transformExpression(node), node)];
     }
     return [context.transformExpression(node)];
 }
 function transformExpressionBodyToReturnStatement(context, node) {
     const expressions = transformExpressionsInReturn(context, node, false);
-    return lua.createReturnStatement(expressions, node);
+    return createReturnStatement(context, expressions, node);
 }
 exports.transformExpressionBodyToReturnStatement = transformExpressionBodyToReturnStatement;
 const transformReturnStatement = (statement, context) => {
-    // Bubble up explicit return flag and check if we're inside a try/catch block
-    let insideTryCatch = false;
-    for (const scope of scope_1.walkScopesUp(context)) {
-        scope.functionReturned = true;
-        if (scope.type === scope_1.ScopeType.Function) {
-            break;
-        }
-        insideTryCatch = insideTryCatch || scope.type === scope_1.ScopeType.Try || scope.type === scope_1.ScopeType.Catch;
-    }
     let results;
     if (statement.expression) {
         const expressionType = context.checker.getTypeAtLocation(statement.expression);
         const returnType = context.checker.getContextualType(statement.expression);
         if (returnType) {
-            assignment_validation_1.validateAssignment(context, statement, expressionType, returnType);
+            (0, assignment_validation_1.validateAssignment)(context, statement, expressionType, returnType);
         }
-        results = transformExpressionsInReturn(context, statement.expression, insideTryCatch);
+        results = transformExpressionsInReturn(context, statement.expression, isInTryCatch(context));
     }
     else {
         // Empty return
         results = [];
     }
-    if (insideTryCatch) {
-        results.unshift(lua.createBooleanLiteral(true));
-    }
-    return lua.createReturnStatement(results, statement);
+    return createReturnStatement(context, results, statement);
 };
 exports.transformReturnStatement = transformReturnStatement;
+function createReturnStatement(context, values, node) {
+    const results = [...values];
+    if (isInTryCatch(context)) {
+        // Bubble up explicit return flag and check if we're inside a try/catch block
+        results.unshift(lua.createBooleanLiteral(true));
+    }
+    else if ((0, typescript_1.isInAsyncFunction)(node)) {
+        // Add nil error handler in async function and not in try
+        results.unshift(lua.createNilLiteral());
+    }
+    return lua.createReturnStatement(results, node);
+}
+exports.createReturnStatement = createReturnStatement;
+function isInTryCatch(context) {
+    // Check if context is in a try or catch
+    let insideTryCatch = false;
+    for (const scope of (0, scope_1.walkScopesUp)(context)) {
+        scope.functionReturned = true;
+        if (scope.type === scope_1.ScopeType.Function) {
+            break;
+        }
+        insideTryCatch = insideTryCatch || scope.type === scope_1.ScopeType.Try || scope.type === scope_1.ScopeType.Catch;
+    }
+    return insideTryCatch;
+}
 //# sourceMappingURL=return.js.map

package/dist/transformation/visitors/sourceFile.js

@@ -6,6 +6,7 @@ const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
 const transformSourceFileNode = (node, context) => {
@@ -14,8 +15,10 @@ const transformSourceFileNode = (node, context) => {
     if (node.flags & ts.NodeFlags.JsonFile) {
         const [statement] = node.statements;
         if (statement) {
-            utils_1.assert(ts.isExpressionStatement(statement));
-            statements.push(lua.createReturnStatement([context.transformExpression(statement.expression)]));
+            (0, utils_1.assert)(ts.isExpressionStatement(statement));
+            const [precedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+            statements.push(...precedingStatements);
+            statements.push(lua.createReturnStatement([expression]));
         }
         else {
             const errorCall = lua.createCallExpression(lua.createIdentifier("error"), [
@@ -25,21 +28,21 @@ const transformSourceFileNode = (node, context) => {
         }
     }
     else {
-        scope_1.pushScope(context, scope_1.ScopeType.File);
-        statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-        scope_1.popScope(context);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.File);
+        statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+        (0, scope_1.popScope)(context);
         if (context.isModule) {
             // If export equals was not used. Create the exports table.
             // local ____exports = {}
-            if (!typescript_1.hasExportEquals(node)) {
-                statements.unshift(lua.createVariableDeclarationStatement(lua_ast_1.createExportsIdentifier(), lua.createTableExpression()));
+            if (!(0, typescript_1.hasExportEquals)(node)) {
+                statements.unshift(lua.createVariableDeclarationStatement((0, lua_ast_1.createExportsIdentifier)(), lua.createTableExpression()));
             }
             // return ____exports
-            statements.push(lua.createReturnStatement([lua_ast_1.createExportsIdentifier()]));
+            statements.push(lua.createReturnStatement([(0, lua_ast_1.createExportsIdentifier)()]));
         }
     }
     const trivia = (_b = (_a = node.getFullText().match(/^#!.*\r?\n/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
-    return lua.createFile(statements, lualib_1.getUsedLuaLibFeatures(context), trivia, node);
+    return lua.createFile(statements, (0, lualib_1.getUsedLuaLibFeatures)(context), trivia, node);
 };
 exports.transformSourceFileNode = transformSourceFileNode;
 //# sourceMappingURL=sourceFile.js.map

package/dist/transformation/visitors/spread.js

@@ -17,16 +17,16 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
         return false;
     }
     // Walk up, stopping at any scope types which could stop optimization
-    const scope = scope_1.findScope(context, scope_1.ScopeType.Function | scope_1.ScopeType.Try | scope_1.ScopeType.Catch | scope_1.ScopeType.File);
+    const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Function | scope_1.ScopeType.Try | scope_1.ScopeType.Catch | scope_1.ScopeType.File);
     if (!scope) {
         return;
     }
     // $vararg global constant
-    if (vararg_1.isGlobalVarargConstant(context, symbol, scope)) {
+    if ((0, vararg_1.isGlobalVarargConstant)(context, symbol, scope)) {
         return true;
     }
     // Scope must be a function scope associated with a real ts function
-    if (!scope_1.isFunctionScopeWithDefinition(scope)) {
+    if (!(0, scope_1.isFunctionScopeWithDefinition)(scope)) {
         return false;
     }
     // Scope cannot be an async function
@@ -39,11 +39,11 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
         return false;
     }
     // De-optimize if already referenced outside of a spread, as the array may have been modified
-    if (scope_1.hasReferencedSymbol(context, scope, symbol)) {
+    if ((0, scope_1.hasReferencedSymbol)(context, scope, symbol)) {
         return false;
     }
     // De-optimize if a function is being hoisted from below to above, as it may have modified the array
-    if (scope_1.hasReferencedUndefinedLocalFunction(context, scope)) {
+    if ((0, scope_1.hasReferencedUndefinedLocalFunction)(context, scope)) {
         return false;
     }
     return true;
@@ -52,8 +52,8 @@ exports.isOptimizedVarArgSpread = isOptimizedVarArgSpread;
 // TODO: Currently it's also used as an array member
 const transformSpreadElement = (node, context) => {
     if (ts.isIdentifier(node.expression)) {
-        if (annotations_1.isVarargType(context, node.expression)) {
-            context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.Vararg));
+        if ((0, annotations_1.isVarargType)(context, node.expression)) {
+            context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Vararg));
         }
         const symbol = context.checker.getSymbolAtLocation(node.expression);
         if (symbol && isOptimizedVarArgSpread(context, symbol, node.expression)) {
@@ -61,13 +61,13 @@ const transformSpreadElement = (node, context) => {
         }
     }
     const innerExpression = context.transformExpression(node.expression);
-    if (multi_1.isMultiReturnCall(context, node.expression))
+    if ((0, multi_1.isMultiReturnCall)(context, node.expression))
         return innerExpression;
     const type = context.checker.getTypeAtLocation(node.expression);
-    if (typescript_1.isArrayType(context, type)) {
-        return lua_ast_1.createUnpackCall(context, innerExpression, node);
+    if ((0, typescript_1.isArrayType)(context, type)) {
+        return (0, lua_ast_1.createUnpackCall)(context, innerExpression, node);
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Spread, node, innerExpression);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Spread, node, innerExpression);
 };
 exports.transformSpreadElement = transformSpreadElement;
 //# sourceMappingURL=spread.js.map