@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/transformOptionalChain.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenOptionalChain = flattenOptionalChain;
+exports.transformOptionalChain = transformOptionalChain;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const transformCallExpression_1 = require("./expressions/transformCallExpression");
+const transformElementAccessExpression_1 = require("./expressions/transformElementAccessExpression");
+const transformExpression_1 = require("./expressions/transformExpression");
+const transformPropertyAccessExpression_1 = require("./expressions/transformPropertyAccessExpression");
+const addOneIfArrayType_1 = require("../util/addOneIfArrayType");
+const convertToIndexableExpression_1 = require("../util/convertToIndexableExpression");
+const ensureTransformOrder_1 = require("../util/ensureTransformOrder");
+const isMethod_1 = require("../util/isMethod");
+const isUsedAsStatement_1 = require("../util/isUsedAsStatement");
+const traversal_1 = require("../util/traversal");
+const types_1 = require("../util/types");
+const wrapReturnIfLuaTuple_1 = require("../util/wrapReturnIfLuaTuple");
+const typescript_1 = __importDefault(require("typescript"));
+var OptionalChainItemKind;
+(function (OptionalChainItemKind) {
+    OptionalChainItemKind[OptionalChainItemKind["PropertyAccess"] = 0] = "PropertyAccess";
+    OptionalChainItemKind[OptionalChainItemKind["ElementAccess"] = 1] = "ElementAccess";
+    OptionalChainItemKind[OptionalChainItemKind["Call"] = 2] = "Call";
+    OptionalChainItemKind[OptionalChainItemKind["PropertyCall"] = 3] = "PropertyCall";
+    OptionalChainItemKind[OptionalChainItemKind["ElementCall"] = 4] = "ElementCall";
+})(OptionalChainItemKind || (OptionalChainItemKind = {}));
+function createPropertyAccessItem(state, node) {
+    return {
+        node,
+        kind: OptionalChainItemKind.PropertyAccess,
+        optional: node.questionDotToken !== undefined,
+        type: state.getType(node.expression),
+        name: node.name.text,
+    };
+}
+function createElementAccessItem(state, node) {
+    return {
+        node,
+        kind: OptionalChainItemKind.ElementAccess,
+        optional: node.questionDotToken !== undefined,
+        type: state.getType(node.expression),
+        expression: node.argumentExpression,
+    };
+}
+function createCallItem(state, node) {
+    return {
+        node,
+        kind: OptionalChainItemKind.Call,
+        optional: node.questionDotToken !== undefined,
+        type: state.getType(node.expression),
+        args: node.arguments,
+    };
+}
+function createPropertyCallItem(state, node, expression) {
+    return {
+        node,
+        expression,
+        kind: OptionalChainItemKind.PropertyCall,
+        optional: expression.questionDotToken !== undefined,
+        type: state.getType(node.expression),
+        name: expression.name.text,
+        callType: state.getType(node),
+        callOptional: node.questionDotToken !== undefined,
+        args: node.arguments,
+    };
+}
+function createElementCallItem(state, node, expression) {
+    return {
+        node,
+        expression,
+        kind: OptionalChainItemKind.ElementCall,
+        optional: expression.questionDotToken !== undefined,
+        type: state.getType(expression),
+        argumentExpression: expression.argumentExpression,
+        callType: state.getType(node),
+        callOptional: node.questionDotToken !== undefined,
+        args: node.arguments,
+    };
+}
+function flattenOptionalChain(state, expression) {
+    const chain = new Array();
+    while (true) {
+        if (typescript_1.default.isPropertyAccessExpression(expression)) {
+            chain.unshift(createPropertyAccessItem(state, expression));
+            expression = expression.expression;
+        }
+        else if (typescript_1.default.isElementAccessExpression(expression)) {
+            chain.unshift(createElementAccessItem(state, expression));
+            expression = expression.expression;
+        }
+        else if (typescript_1.default.isCallExpression(expression)) {
+            const subExp = (0, traversal_1.skipDownwards)(expression.expression);
+            if (typescript_1.default.isPropertyAccessExpression(subExp)) {
+                chain.unshift(createPropertyCallItem(state, expression, subExp));
+                expression = subExp.expression;
+            }
+            else if (typescript_1.default.isElementAccessExpression(subExp)) {
+                chain.unshift(createElementCallItem(state, expression, subExp));
+                expression = subExp.expression;
+            }
+            else {
+                chain.unshift(createCallItem(state, expression));
+                expression = subExp;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return { chain, expression };
+}
+function transformChainItem(state, baseExpression, item) {
+    if (item.kind === OptionalChainItemKind.PropertyAccess) {
+        return (0, transformPropertyAccessExpression_1.transformPropertyAccessExpressionInner)(state, item.node, baseExpression, item.name);
+    }
+    else if (item.kind === OptionalChainItemKind.ElementAccess) {
+        return (0, transformElementAccessExpression_1.transformElementAccessExpressionInner)(state, item.node, baseExpression, item.expression);
+    }
+    else if (item.kind === OptionalChainItemKind.Call) {
+        return (0, transformCallExpression_1.transformCallExpressionInner)(state, item.node, baseExpression, item.args);
+    }
+    else if (item.kind === OptionalChainItemKind.PropertyCall) {
+        return (0, transformCallExpression_1.transformPropertyCallExpressionInner)(state, item.node, item.expression, baseExpression, item.name, item.args);
+    }
+    else {
+        return (0, transformCallExpression_1.transformElementCallExpressionInner)(state, item.node, item.expression, baseExpression, item.argumentExpression, item.args);
+    }
+}
+function createOrSetTempId(state, tempId, expression, node) {
+    if (tempId === undefined) {
+        tempId = state.pushToVar(expression, node.parent && typescript_1.default.isVariableDeclaration(node.parent) && typescript_1.default.isIdentifier(node.parent.name)
+            ? node.parent.name.text
+            : "result");
+    }
+    else {
+        if (tempId !== expression) {
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: tempId,
+                operator: "=",
+                right: expression,
+            }));
+        }
+    }
+    return tempId;
+}
+function createNilCheck(tempId, statements) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: luau_ast_1.default.binary(tempId, "~=", luau_ast_1.default.nil()),
+        statements,
+        elseBody: luau_ast_1.default.list.make(),
+    });
+}
+function isCompoundCall(item) {
+    return item.kind === OptionalChainItemKind.PropertyCall || item.kind === OptionalChainItemKind.ElementCall;
+}
+function transformOptionalChainInner(state, chain, baseExpression, tempId = undefined, index = 0) {
+    if (index >= chain.length)
+        return baseExpression;
+    const item = chain[index];
+    if (item.optional || (isCompoundCall(item) && item.callOptional)) {
+        let isMethodCall = false;
+        let isSuperCall = false;
+        let selfParam;
+        if (isCompoundCall(item)) {
+            isMethodCall = (0, isMethod_1.isMethod)(state, item.expression);
+            isSuperCall = typescript_1.default.isSuperProperty(item.expression);
+            if (item.callOptional && isMethodCall && !isSuperCall) {
+                selfParam = state.pushToVar(baseExpression, "self");
+                baseExpression = selfParam;
+            }
+            if (item.optional) {
+                tempId = createOrSetTempId(state, tempId, baseExpression, chain[chain.length - 1].node);
+                baseExpression = tempId;
+            }
+            if (item.callOptional) {
+                if (item.kind === OptionalChainItemKind.PropertyCall) {
+                    baseExpression = luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression), item.name);
+                }
+                else {
+                    const expType = state.getType(item.expression.expression);
+                    baseExpression = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                        expression: (0, convertToIndexableExpression_1.convertToIndexableExpression)(baseExpression),
+                        index: (0, addOneIfArrayType_1.addOneIfArrayType)(state, expType, (0, transformExpression_1.transformExpression)(state, item.argumentExpression)),
+                    });
+                }
+            }
+        }
+        const [result, prereqStatements] = state.capture(() => {
+            tempId = createOrSetTempId(state, tempId, baseExpression, chain[chain.length - 1].node);
+            const [newValue, ifStatements] = state.capture(() => {
+                let newExpression;
+                if (isCompoundCall(item) && item.callOptional) {
+                    const expType = state.typeChecker.getNonOptionalType(state.getType(item.node.expression));
+                    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+                    if (symbol) {
+                        const macro = state.services.macroManager.getPropertyCallMacro(symbol);
+                        if (macro) {
+                            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noOptionalMacroCall(item.node));
+                            return luau_ast_1.default.none();
+                        }
+                    }
+                    const args = (0, ensureTransformOrder_1.ensureTransformOrder)(state, item.args);
+                    if (isMethodCall) {
+                        if (isSuperCall) {
+                            args.unshift(luau_ast_1.default.globals.self);
+                        }
+                        else {
+                            args.unshift(selfParam);
+                        }
+                    }
+                    newExpression = (0, wrapReturnIfLuaTuple_1.wrapReturnIfLuaTuple)(state, item.node, luau_ast_1.default.call(tempId, args));
+                }
+                else {
+                    newExpression = transformChainItem(state, tempId, item);
+                }
+                return transformOptionalChainInner(state, chain, newExpression, tempId, index + 1);
+            });
+            const isUsed = !luau_ast_1.default.isNone(newValue) && !(0, isUsedAsStatement_1.isUsedAsStatement)(item.node);
+            if (tempId !== newValue && isUsed) {
+                luau_ast_1.default.list.push(ifStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                    left: tempId,
+                    operator: "=",
+                    right: newValue,
+                }));
+            }
+            else {
+                if (luau_ast_1.default.isCall(newValue)) {
+                    luau_ast_1.default.list.push(ifStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                        expression: newValue,
+                    }));
+                }
+            }
+            state.prereq(createNilCheck(tempId, ifStatements));
+            return isUsed ? tempId : luau_ast_1.default.none();
+        });
+        if (isCompoundCall(item) && item.optional && item.callOptional) {
+            state.prereq(createNilCheck(tempId, prereqStatements));
+        }
+        else {
+            state.prereqList(prereqStatements);
+        }
+        return result;
+    }
+    else {
+        return transformOptionalChainInner(state, chain, transformChainItem(state, baseExpression, item), tempId, index + 1);
+    }
+}
+function transformOptionalChain(state, node) {
+    const { chain, expression } = flattenOptionalChain(state, node);
+    return transformOptionalChainInner(state, chain, (0, transformExpression_1.transformExpression)(state, expression));
+}
+//# sourceMappingURL=transformOptionalChain.js.map

package/out/TSTransformer/nodes/transformParameters.d.ts

@@ -0,0 +1,8 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformParameters(state: TransformState, node: ts.SignatureDeclarationBase): {
+    parameters: luau.List<luau.AnyIdentifier>;
+    statements: luau.List<luau.Statement<luau.SyntaxKind>>;
+    hasDotDotDot: boolean;
+};

package/out/TSTransformer/nodes/transformParameters.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformParameters = transformParameters;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformArrayBindingPattern_1 = require("./binding/transformArrayBindingPattern");
+const transformObjectBindingPattern_1 = require("./binding/transformObjectBindingPattern");
+const transformIdentifier_1 = require("./expressions/transformIdentifier");
+const transformInitializer_1 = require("./transformInitializer");
+const arrayLikeExpressionContainsSpread_1 = require("../util/arrayLikeExpressionContainsSpread");
+const isMethod_1 = require("../util/isMethod");
+const validateIdentifier_1 = require("../util/validateIdentifier");
+const typescript_1 = __importDefault(require("typescript"));
+function optimizeArraySpreadParameter(state, parameters, bindingPattern) {
+    for (const element of bindingPattern.elements) {
+        if (typescript_1.default.isOmittedExpression(element)) {
+            luau_ast_1.default.list.push(parameters, luau_ast_1.default.tempId());
+        }
+        else {
+            const name = element.name;
+            if (typescript_1.default.isIdentifier(name)) {
+                const paramId = (0, transformIdentifier_1.transformIdentifierDefined)(state, name);
+                (0, validateIdentifier_1.validateIdentifier)(state, name);
+                luau_ast_1.default.list.push(parameters, paramId);
+                if (element.initializer) {
+                    state.prereq((0, transformInitializer_1.transformInitializer)(state, paramId, element.initializer));
+                }
+            }
+            else {
+                const paramId = luau_ast_1.default.tempId("param");
+                luau_ast_1.default.list.push(parameters, paramId);
+                if (element.initializer) {
+                    state.prereq((0, transformInitializer_1.transformInitializer)(state, paramId, element.initializer));
+                }
+                if (typescript_1.default.isArrayBindingPattern(name)) {
+                    (0, transformArrayBindingPattern_1.transformArrayBindingPattern)(state, name, paramId);
+                }
+                else {
+                    (0, transformObjectBindingPattern_1.transformObjectBindingPattern)(state, name, paramId);
+                }
+            }
+        }
+    }
+}
+function transformParameters(state, node) {
+    const parameters = luau_ast_1.default.list.make();
+    const statements = luau_ast_1.default.list.make();
+    let hasDotDotDot = false;
+    if ((0, isMethod_1.isMethod)(state, node)) {
+        luau_ast_1.default.list.push(parameters, luau_ast_1.default.globals.self);
+    }
+    for (const parameter of node.parameters) {
+        if (typescript_1.default.isThisIdentifier(parameter.name)) {
+            continue;
+        }
+        if (parameter.dotDotDotToken &&
+            typescript_1.default.isArrayBindingPattern(parameter.name) &&
+            !(0, arrayLikeExpressionContainsSpread_1.arrayLikeExpressionContainsSpread)(parameter.name)) {
+            const prereqs = state.capturePrereqs(() => optimizeArraySpreadParameter(state, parameters, parameter.name));
+            luau_ast_1.default.list.pushList(statements, prereqs);
+            continue;
+        }
+        let paramId;
+        if (typescript_1.default.isIdentifier(parameter.name)) {
+            paramId = (0, transformIdentifier_1.transformIdentifierDefined)(state, parameter.name);
+            (0, validateIdentifier_1.validateIdentifier)(state, parameter.name);
+        }
+        else {
+            paramId = luau_ast_1.default.tempId("param");
+        }
+        if (parameter.dotDotDotToken) {
+            hasDotDotDot = true;
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: paramId,
+                right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Array, {
+                    members: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VarArgsLiteral, {})),
+                }),
+            }));
+        }
+        else {
+            luau_ast_1.default.list.push(parameters, paramId);
+        }
+        if (parameter.initializer) {
+            luau_ast_1.default.list.push(statements, (0, transformInitializer_1.transformInitializer)(state, paramId, parameter.initializer));
+        }
+        if (!typescript_1.default.isIdentifier(parameter.name)) {
+            const bindingPattern = parameter.name;
+            if (typescript_1.default.isArrayBindingPattern(bindingPattern)) {
+                luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => (0, transformArrayBindingPattern_1.transformArrayBindingPattern)(state, bindingPattern, paramId)));
+            }
+            else {
+                luau_ast_1.default.list.pushList(statements, state.capturePrereqs(() => (0, transformObjectBindingPattern_1.transformObjectBindingPattern)(state, bindingPattern, paramId)));
+            }
+        }
+    }
+    return {
+        parameters,
+        statements,
+        hasDotDotDot,
+    };
+}
+//# sourceMappingURL=transformParameters.js.map

package/out/TSTransformer/nodes/transformPropertyName.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformPropertyName(state: TransformState, name: ts.PropertyName): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/nodes/transformPropertyName.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPropertyName = transformPropertyName;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./expressions/transformExpression");
+const typescript_1 = __importDefault(require("typescript"));
+function transformPropertyName(state, name) {
+    if (typescript_1.default.isIdentifier(name)) {
+        return luau_ast_1.default.string(name.text);
+    }
+    else {
+        return (0, transformExpression_1.transformExpression)(state, typescript_1.default.isComputedPropertyName(name) ? name.expression : name);
+    }
+}
+//# sourceMappingURL=transformPropertyName.js.map

package/out/TSTransformer/nodes/transformSourceFile.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformSourceFile(state: TransformState, node: ts.SourceFile): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/transformSourceFile.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSourceFile = transformSourceFile;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const constants_1 = require("../../Shared/constants");
+const assert_1 = require("../../Shared/util/assert");
+const transformIdentifier_1 = require("./expressions/transformIdentifier");
+const transformStatementList_1 = require("./transformStatementList");
+const getOriginalSymbolOfNode_1 = require("../util/getOriginalSymbolOfNode");
+const isSymbolMutable_1 = require("../util/isSymbolMutable");
+const isSymbolOfValue_1 = require("../util/isSymbolOfValue");
+const traversal_1 = require("../util/traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function getExportPair(state, exportSymbol) {
+    var _a, _b;
+    const declaration = (_a = exportSymbol.getDeclarations()) === null || _a === void 0 ? void 0 : _a[0];
+    if (declaration && typescript_1.default.isExportSpecifier(declaration)) {
+        return [declaration.name.text, (0, transformIdentifier_1.transformIdentifierDefined)(state, (_b = declaration.propertyName) !== null && _b !== void 0 ? _b : declaration.name)];
+    }
+    else {
+        let name = exportSymbol.name;
+        if (exportSymbol.name === "default" &&
+            declaration &&
+            (typescript_1.default.isFunctionDeclaration(declaration) || typescript_1.default.isClassDeclaration(declaration)) &&
+            declaration.name) {
+            name = declaration.name.text;
+        }
+        return [exportSymbol.name, luau_ast_1.default.id(name)];
+    }
+}
+function isExportSymbolFromExportFrom(exportSymbol) {
+    if (exportSymbol.declarations) {
+        for (const exportSpecifier of exportSymbol.declarations) {
+            if (typescript_1.default.isExportSpecifier(exportSpecifier)) {
+                const exportDec = exportSpecifier.parent.parent;
+                if (typescript_1.default.isExportDeclaration(exportDec) && exportDec.moduleSpecifier) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function getIgnoredExportSymbols(state, sourceFile) {
+    const ignoredSymbols = new Set();
+    for (const statement of sourceFile.statements) {
+        if (typescript_1.default.isExportDeclaration(statement) && statement.moduleSpecifier) {
+            if (!statement.exportClause) {
+                const moduleSymbol = (0, getOriginalSymbolOfNode_1.getOriginalSymbolOfNode)(state.typeChecker, statement.moduleSpecifier);
+                if (moduleSymbol) {
+                    state.getModuleExports(moduleSymbol).forEach(v => ignoredSymbols.add(v));
+                }
+            }
+            else if (typescript_1.default.isNamespaceExport(statement.exportClause)) {
+                const idSymbol = state.typeChecker.getSymbolAtLocation(statement.exportClause.name);
+                if (idSymbol) {
+                    ignoredSymbols.add(idSymbol);
+                }
+            }
+        }
+    }
+    return ignoredSymbols;
+}
+function isExportSymbolOnlyFromDeclare(exportSymbol) {
+    var _a, _b;
+    return ((_b = (_a = exportSymbol.declarations) === null || _a === void 0 ? void 0 : _a.every(declaration => {
+        const statement = (0, traversal_1.getAncestor)(declaration, typescript_1.default.isStatement);
+        const modifiers = statement && typescript_1.default.canHaveModifiers(statement) ? typescript_1.default.getModifiers(statement) : undefined;
+        return modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(v => v.kind === typescript_1.default.SyntaxKind.DeclareKeyword);
+    })) !== null && _b !== void 0 ? _b : false);
+}
+function handleExports(state, sourceFile, symbol, statements) {
+    const ignoredExportSymbols = getIgnoredExportSymbols(state, sourceFile);
+    let mustPushExports = state.hasExportFrom;
+    const exportPairs = new Array();
+    if (!state.hasExportEquals) {
+        for (const exportSymbol of state.getModuleExports(symbol)) {
+            if (ignoredExportSymbols.has(exportSymbol))
+                continue;
+            if (!!(exportSymbol.flags & typescript_1.default.SymbolFlags.Prototype))
+                continue;
+            if (isExportSymbolFromExportFrom(exportSymbol))
+                continue;
+            const originalSymbol = typescript_1.default.skipAlias(exportSymbol, state.typeChecker);
+            if (!(0, isSymbolOfValue_1.isSymbolOfValue)(originalSymbol))
+                continue;
+            if ((0, isSymbolMutable_1.isSymbolMutable)(state, originalSymbol)) {
+                mustPushExports = true;
+                continue;
+            }
+            if (isExportSymbolOnlyFromDeclare(exportSymbol))
+                continue;
+            exportPairs.push(getExportPair(state, exportSymbol));
+        }
+    }
+    if (state.hasExportEquals) {
+        const finalStatement = sourceFile.statements[sourceFile.statements.length - 1];
+        if (!(typescript_1.default.isExportAssignment(finalStatement) && finalStatement.isExportEquals)) {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                expression: luau_ast_1.default.globals.exports,
+            }));
+        }
+    }
+    else if (mustPushExports) {
+        luau_ast_1.default.list.unshift(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: luau_ast_1.default.globals.exports,
+            right: luau_ast_1.default.map(),
+        }));
+        for (const [exportKey, exportId] of exportPairs) {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.property(luau_ast_1.default.globals.exports, exportKey),
+                operator: "=",
+                right: exportId,
+            }));
+        }
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: luau_ast_1.default.globals.exports,
+        }));
+    }
+    else if (exportPairs.length > 0) {
+        const fields = luau_ast_1.default.list.make();
+        for (const [exportKey, exportId] of exportPairs) {
+            luau_ast_1.default.list.push(fields, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MapField, {
+                index: luau_ast_1.default.string(exportKey),
+                value: exportId,
+            }));
+        }
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Map, {
+                fields,
+            }),
+        }));
+    }
+}
+function getLastNonCommentStatement(listNode) {
+    while (listNode && luau_ast_1.default.isComment(listNode.value)) {
+        listNode = listNode.prev;
+    }
+    return listNode;
+}
+function transformSourceFile(state, node) {
+    const symbol = state.typeChecker.getSymbolAtLocation(node);
+    (0, assert_1.assert)(symbol);
+    state.setModuleIdBySymbol(symbol, luau_ast_1.default.globals.exports);
+    const statements = (0, transformStatementList_1.transformStatementList)(state, node, node.statements, undefined);
+    handleExports(state, node, symbol, statements);
+    const lastStatement = getLastNonCommentStatement(statements.tail);
+    if (!lastStatement || !luau_ast_1.default.isReturnStatement(lastStatement.value)) {
+        const outputPath = state.pathTranslator.getOutputPath(node.fileName);
+        if (state.rojoResolver.getRbxTypeFromFilePath(outputPath) === rojo_resolver_1.RbxType.ModuleScript) {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, { expression: luau_ast_1.default.nil() }));
+        }
+    }
+    const headerStatements = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.push(headerStatements, luau_ast_1.default.comment(` Compiled with roblox-ts v${constants_1.COMPILER_VERSION}`));
+    if (state.usesRuntimeLib) {
+        luau_ast_1.default.list.push(headerStatements, state.createRuntimeLibImport(node));
+    }
+    const directiveComments = luau_ast_1.default.list.make();
+    while (statements.head && luau_ast_1.default.isComment(statements.head.value) && statements.head.value.text.startsWith("!")) {
+        luau_ast_1.default.list.push(directiveComments, luau_ast_1.default.list.shift(statements));
+    }
+    luau_ast_1.default.list.unshiftList(statements, headerStatements);
+    luau_ast_1.default.list.unshiftList(statements, directiveComments);
+    return statements;
+}
+//# sourceMappingURL=transformSourceFile.js.map

package/out/TSTransformer/nodes/transformStatementList.d.ts

@@ -0,0 +1,7 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformStatementList(state: TransformState, parent: ts.Node | undefined, statements: ReadonlyArray<ts.Statement>, exportInfo?: {
+    id: luau.AnyIdentifier;
+    mapping: Map<ts.Statement, Array<string>>;
+}): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/transformStatementList.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStatementList = transformStatementList;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformStatement_1 = require("./statements/transformStatement");
+const createHoistDeclaration_1 = require("../util/createHoistDeclaration");
+const typescript_1 = __importDefault(require("typescript"));
+function getLastToken(parent, statements) {
+    if (statements.length > 0) {
+        const lastStatement = statements[statements.length - 1];
+        const lastToken = lastStatement.parent.getLastToken();
+        if (lastToken && !typescript_1.default.isNodeDescendantOf(lastToken, lastStatement)) {
+            return lastToken;
+        }
+    }
+    else if (parent) {
+        return parent.getLastToken();
+    }
+}
+function transformStatementList(state, parent, statements, exportInfo) {
+    var _a;
+    const result = luau_ast_1.default.list.make();
+    for (const statement of statements) {
+        const [transformedStatements, prereqStatements] = state.capture(() => (0, transformStatement_1.transformStatement)(state, statement));
+        if (state.compilerOptions.removeComments !== true) {
+            luau_ast_1.default.list.pushList(result, state.getLeadingComments(statement));
+        }
+        const hoistDeclaration = (0, createHoistDeclaration_1.createHoistDeclaration)(state, statement);
+        if (hoistDeclaration) {
+            luau_ast_1.default.list.push(result, hoistDeclaration);
+        }
+        luau_ast_1.default.list.pushList(result, prereqStatements);
+        luau_ast_1.default.list.pushList(result, transformedStatements);
+        const lastStatement = (_a = transformedStatements.tail) === null || _a === void 0 ? void 0 : _a.value;
+        if (lastStatement && luau_ast_1.default.isFinalStatement(lastStatement)) {
+            break;
+        }
+        if (exportInfo) {
+            const containerId = exportInfo.id;
+            const exportMapping = exportInfo.mapping.get(statement);
+            if (exportMapping !== undefined) {
+                for (const exportName of exportMapping) {
+                    luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                        left: luau_ast_1.default.property(containerId, exportName),
+                        operator: "=",
+                        right: luau_ast_1.default.id(exportName),
+                    }));
+                }
+            }
+        }
+    }
+    if (state.compilerOptions.removeComments !== true) {
+        const lastToken = getLastToken(parent, statements);
+        if (lastToken) {
+            luau_ast_1.default.list.pushList(result, state.getLeadingComments(lastToken));
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=transformStatementList.js.map

package/out/TSTransformer/nodes/transformWritable.d.ts

@@ -0,0 +1,9 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function transformWritableExpression(state: TransformState, node: ts.Expression, readAfterWrite: boolean): luau.WritableExpression;
+export declare function transformWritableAssignment(state: TransformState, writeNode: ts.Expression, valueNode: ts.Expression, readAfterWrite?: boolean, readBeforeWrite?: boolean): {
+    writable: luau.WritableExpression;
+    readable: luau.WritableExpression;
+    value: luau.Expression<luau.SyntaxKind>;
+};