@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/statements/transformModuleDeclaration.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformModuleDeclaration = transformModuleDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const getOrSetDefault_1 = require("../../../Shared/util/getOrSetDefault");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformIdentifier_1 = require("../expressions/transformIdentifier");
+const transformStatementList_1 = require("../transformStatementList");
+const hasMultipleDefinitions_1 = require("../../util/hasMultipleDefinitions");
+const isSymbolMutable_1 = require("../../util/isSymbolMutable");
+const isSymbolOfValue_1 = require("../../util/isSymbolOfValue");
+const traversal_1 = require("../../util/traversal");
+const validateIdentifier_1 = require("../../util/validateIdentifier");
+const typescript_1 = __importDefault(require("typescript"));
+function isDeclarationOfNamespace(declaration) {
+    const modifiers = typescript_1.default.canHaveModifiers(declaration) ? typescript_1.default.getModifiers(declaration) : undefined;
+    if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(v => v.kind === typescript_1.default.SyntaxKind.DeclareKeyword)) {
+        return false;
+    }
+    if (typescript_1.default.isModuleDeclaration(declaration) && typescript_1.default.isInstantiatedModule(declaration, false)) {
+        return true;
+    }
+    else if (typescript_1.default.isFunctionDeclaration(declaration) && declaration.body) {
+        return true;
+    }
+    else if (typescript_1.default.isClassDeclaration(declaration)) {
+        return true;
+    }
+    return false;
+}
+function getValueDeclarationStatement(symbol) {
+    var _a;
+    for (const declaration of (_a = symbol.getDeclarations()) !== null && _a !== void 0 ? _a : []) {
+        const statement = (0, traversal_1.getAncestor)(declaration, typescript_1.default.isStatement);
+        if (statement) {
+            const modifiers = typescript_1.default.canHaveModifiers(statement) ? typescript_1.default.getModifiers(statement) : undefined;
+            if (typescript_1.default.isFunctionDeclaration(statement) && !statement.body)
+                continue;
+            if (typescript_1.default.isTypeAliasDeclaration(statement))
+                continue;
+            if (typescript_1.default.isInterfaceDeclaration(statement))
+                continue;
+            if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(v => v.kind === typescript_1.default.SyntaxKind.DeclareKeyword))
+                continue;
+            return statement;
+        }
+    }
+}
+function transformNamespace(state, name, body) {
+    const symbol = state.typeChecker.getSymbolAtLocation(name);
+    (0, assert_1.assert)(symbol);
+    (0, validateIdentifier_1.validateIdentifier)(state, name);
+    const nameExp = (0, transformIdentifier_1.transformIdentifierDefined)(state, name);
+    const statements = luau_ast_1.default.list.make();
+    const doStatements = luau_ast_1.default.list.make();
+    const containerId = luau_ast_1.default.tempId("container");
+    state.setModuleIdBySymbol(symbol, containerId);
+    if (state.isHoisted.get(symbol)) {
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: nameExp,
+            operator: "=",
+            right: luau_ast_1.default.map(),
+        }));
+    }
+    else {
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: nameExp,
+            right: luau_ast_1.default.map(),
+        }));
+    }
+    const moduleExports = state.getModuleExports(symbol);
+    if (moduleExports.length > 0) {
+        luau_ast_1.default.list.push(doStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, { left: containerId, right: nameExp }));
+    }
+    if (typescript_1.default.isModuleBlock(body)) {
+        const exportsMap = new Map();
+        if (moduleExports.length > 0) {
+            for (const exportSymbol of moduleExports) {
+                const originalSymbol = typescript_1.default.skipAlias(exportSymbol, state.typeChecker);
+                if ((0, isSymbolOfValue_1.isSymbolOfValue)(originalSymbol) && !(0, isSymbolMutable_1.isSymbolMutable)(state, originalSymbol)) {
+                    const valueDeclarationStatement = getValueDeclarationStatement(exportSymbol);
+                    if (valueDeclarationStatement) {
+                        (0, getOrSetDefault_1.getOrSetDefault)(exportsMap, valueDeclarationStatement, () => []).push(exportSymbol.name);
+                    }
+                }
+            }
+        }
+        luau_ast_1.default.list.pushList(doStatements, (0, transformStatementList_1.transformStatementList)(state, body, body.statements, {
+            id: containerId,
+            mapping: exportsMap,
+        }));
+    }
+    else {
+        luau_ast_1.default.list.pushList(doStatements, transformNamespace(state, body.name, body.body));
+        luau_ast_1.default.list.push(doStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: luau_ast_1.default.property(containerId, body.name.text),
+            operator: "=",
+            right: (0, transformIdentifier_1.transformIdentifierDefined)(state, body.name),
+        }));
+    }
+    luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.DoStatement, { statements: doStatements }));
+    return statements;
+}
+function transformModuleDeclaration(state, node) {
+    if (!typescript_1.default.isInstantiatedModule(node, false)) {
+        return luau_ast_1.default.list.make();
+    }
+    const symbol = state.typeChecker.getSymbolAtLocation(node.name);
+    if (symbol && (0, hasMultipleDefinitions_1.hasMultipleDefinitions)(symbol, declaration => isDeclarationOfNamespace(declaration))) {
+        DiagnosticService_1.DiagnosticService.addDiagnosticWithCache(symbol, diagnostics_1.errors.noNamespaceMerging(node), state.multiTransformState.isReportedByMultipleDefinitionsCache);
+        return luau_ast_1.default.list.make();
+    }
+    (0, assert_1.assert)(!typescript_1.default.isStringLiteral(node.name));
+    (0, assert_1.assert)(node.body && !typescript_1.default.isIdentifier(node.body));
+    return transformNamespace(state, node.name, node.body);
+}
+//# sourceMappingURL=transformModuleDeclaration.js.map

package/out/TSTransformer/nodes/statements/transformReturnStatement.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformReturnStatementInner(state: TransformState, returnExp: ts.Expression): luau.List<luau.Statement>;
+export declare function transformReturnStatement(state: TransformState, node: ts.ReturnStatement): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformReturnStatement.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReturnStatementInner = transformReturnStatementInner;
+exports.transformReturnStatement = transformReturnStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const TSTransformer_1 = require("../..");
+const transformExpression_1 = require("../expressions/transformExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const isBlockedByTryStatement_1 = require("../../util/isBlockedByTryStatement");
+const traversal_1 = require("../../util/traversal");
+const types_1 = require("../../util/types");
+const typescript_1 = __importDefault(require("typescript"));
+function isTupleReturningCall(state, tsExpression, luaExpression) {
+    return (luau_ast_1.default.isCall(luaExpression) &&
+        (0, types_1.isLuaTupleType)(state)(state.typeChecker.getTypeAtLocation((0, traversal_1.skipDownwards)(tsExpression))));
+}
+function isTupleMacro(state, expression) {
+    if (typescript_1.default.isCallExpression(expression)) {
+        const symbol = (0, types_1.getFirstDefinedSymbol)(state, state.getType(expression.expression));
+        if (symbol && symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.$tuple)) {
+            return true;
+        }
+    }
+    return false;
+}
+function transformReturnStatementInner(state, returnExp) {
+    const result = luau_ast_1.default.list.make();
+    let expression;
+    const innerReturnExp = (0, traversal_1.skipDownwards)(returnExp);
+    if (typescript_1.default.isCallExpression(innerReturnExp) && isTupleMacro(state, innerReturnExp)) {
+        const [args, prereqs] = state.capture(() => (0, ensureTransformOrder_1.ensureTransformOrder)(state, innerReturnExp.arguments));
+        luau_ast_1.default.list.pushList(result, prereqs);
+        expression = luau_ast_1.default.list.make(...args);
+    }
+    else {
+        expression = (0, transformExpression_1.transformExpression)(state, innerReturnExp);
+        if ((0, types_1.isLuaTupleType)(state)(state.getType(returnExp)) && !isTupleReturningCall(state, returnExp, expression)) {
+            if (luau_ast_1.default.isArray(expression)) {
+                expression = expression.members;
+            }
+            else {
+                expression = luau_ast_1.default.call(luau_ast_1.default.globals.unpack, [expression]);
+            }
+        }
+    }
+    if ((0, isBlockedByTryStatement_1.isReturnBlockedByTryStatement)(returnExp)) {
+        state.markTryUses("usesReturn");
+        luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: luau_ast_1.default.list.make(state.TS(returnExp, "TRY_RETURN"), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Array, {
+                members: luau_ast_1.default.list.isList(expression) ? expression : luau_ast_1.default.list.make(expression),
+            })),
+        }));
+    }
+    else {
+        luau_ast_1.default.list.push(result, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, { expression }));
+    }
+    return result;
+}
+function transformReturnStatement(state, node) {
+    if (!node.expression) {
+        if ((0, isBlockedByTryStatement_1.isReturnBlockedByTryStatement)(node)) {
+            state.markTryUses("usesReturn");
+            return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                expression: luau_ast_1.default.list.make(state.TS(node, "TRY_RETURN"), luau_ast_1.default.array()),
+            }));
+        }
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, { expression: luau_ast_1.default.nil() }));
+    }
+    return transformReturnStatementInner(state, node.expression);
+}
+//# sourceMappingURL=transformReturnStatement.js.map

package/out/TSTransformer/nodes/statements/transformStatement.d.ts

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

package/out/TSTransformer/nodes/statements/transformStatement.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStatement = transformStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformBlock_1 = require("./transformBlock");
+const transformBreakStatement_1 = require("./transformBreakStatement");
+const transformClassDeclaration_1 = require("./transformClassDeclaration");
+const transformContinueStatement_1 = require("./transformContinueStatement");
+const transformDoStatement_1 = require("./transformDoStatement");
+const transformEnumDeclaration_1 = require("./transformEnumDeclaration");
+const transformExportAssignment_1 = require("./transformExportAssignment");
+const transformExportDeclaration_1 = require("./transformExportDeclaration");
+const transformExpressionStatement_1 = require("./transformExpressionStatement");
+const transformForOfStatement_1 = require("./transformForOfStatement");
+const transformForStatement_1 = require("./transformForStatement");
+const transformFunctionDeclaration_1 = require("./transformFunctionDeclaration");
+const transformIfStatement_1 = require("./transformIfStatement");
+const transformImportDeclaration_1 = require("./transformImportDeclaration");
+const transformImportEqualsDeclaration_1 = require("./transformImportEqualsDeclaration");
+const transformModuleDeclaration_1 = require("./transformModuleDeclaration");
+const transformReturnStatement_1 = require("./transformReturnStatement");
+const transformSwitchStatement_1 = require("./transformSwitchStatement");
+const transformThrowStatement_1 = require("./transformThrowStatement");
+const transformTryStatement_1 = require("./transformTryStatement");
+const transformVariableStatement_1 = require("./transformVariableStatement");
+const transformWhileStatement_1 = require("./transformWhileStatement");
+const getKindName_1 = require("../../util/getKindName");
+const typescript_1 = __importDefault(require("typescript"));
+const NO_EMIT = () => luau_ast_1.default.list.make();
+const DIAGNOSTIC = (factory) => (state, node) => {
+    DiagnosticService_1.DiagnosticService.addDiagnostic(factory(node));
+    return NO_EMIT();
+};
+function createTransformerMap(values) {
+    return new Map(values);
+}
+const TRANSFORMER_BY_KIND = createTransformerMap([
+    [typescript_1.default.SyntaxKind.InterfaceDeclaration, NO_EMIT],
+    [typescript_1.default.SyntaxKind.TypeAliasDeclaration, NO_EMIT],
+    [typescript_1.default.SyntaxKind.EmptyStatement, NO_EMIT],
+    [typescript_1.default.SyntaxKind.ForInStatement, DIAGNOSTIC(diagnostics_1.errors.noForInStatement)],
+    [typescript_1.default.SyntaxKind.LabeledStatement, DIAGNOSTIC(diagnostics_1.errors.noLabeledStatement)],
+    [typescript_1.default.SyntaxKind.DebuggerStatement, DIAGNOSTIC(diagnostics_1.errors.noDebuggerStatement)],
+    [typescript_1.default.SyntaxKind.Block, transformBlock_1.transformBlock],
+    [typescript_1.default.SyntaxKind.BreakStatement, transformBreakStatement_1.transformBreakStatement],
+    [typescript_1.default.SyntaxKind.ClassDeclaration, transformClassDeclaration_1.transformClassDeclaration],
+    [typescript_1.default.SyntaxKind.ContinueStatement, transformContinueStatement_1.transformContinueStatement],
+    [typescript_1.default.SyntaxKind.DoStatement, transformDoStatement_1.transformDoStatement],
+    [typescript_1.default.SyntaxKind.EnumDeclaration, transformEnumDeclaration_1.transformEnumDeclaration],
+    [typescript_1.default.SyntaxKind.ExportAssignment, transformExportAssignment_1.transformExportAssignment],
+    [typescript_1.default.SyntaxKind.ExportDeclaration, transformExportDeclaration_1.transformExportDeclaration],
+    [typescript_1.default.SyntaxKind.ExpressionStatement, transformExpressionStatement_1.transformExpressionStatement],
+    [typescript_1.default.SyntaxKind.ForOfStatement, transformForOfStatement_1.transformForOfStatement],
+    [typescript_1.default.SyntaxKind.ForStatement, transformForStatement_1.transformForStatement],
+    [typescript_1.default.SyntaxKind.FunctionDeclaration, transformFunctionDeclaration_1.transformFunctionDeclaration],
+    [typescript_1.default.SyntaxKind.IfStatement, transformIfStatement_1.transformIfStatement],
+    [typescript_1.default.SyntaxKind.ImportDeclaration, transformImportDeclaration_1.transformImportDeclaration],
+    [typescript_1.default.SyntaxKind.ImportEqualsDeclaration, transformImportEqualsDeclaration_1.transformImportEqualsDeclaration],
+    [typescript_1.default.SyntaxKind.ModuleDeclaration, transformModuleDeclaration_1.transformModuleDeclaration],
+    [typescript_1.default.SyntaxKind.ReturnStatement, transformReturnStatement_1.transformReturnStatement],
+    [typescript_1.default.SyntaxKind.SwitchStatement, transformSwitchStatement_1.transformSwitchStatement],
+    [typescript_1.default.SyntaxKind.ThrowStatement, transformThrowStatement_1.transformThrowStatement],
+    [typescript_1.default.SyntaxKind.TryStatement, transformTryStatement_1.transformTryStatement],
+    [typescript_1.default.SyntaxKind.VariableStatement, transformVariableStatement_1.transformVariableStatement],
+    [typescript_1.default.SyntaxKind.WhileStatement, transformWhileStatement_1.transformWhileStatement],
+]);
+function transformStatement(state, node) {
+    const modifiers = typescript_1.default.canHaveModifiers(node) ? typescript_1.default.getModifiers(node) : undefined;
+    if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(v => v.kind === typescript_1.default.SyntaxKind.DeclareKeyword))
+        return NO_EMIT();
+    const transformer = TRANSFORMER_BY_KIND.get(node.kind);
+    if (transformer) {
+        return transformer(state, node);
+    }
+    (0, assert_1.assert)(false, `Unknown statement: ${(0, getKindName_1.getKindName)(node.kind)}`);
+}
+//# sourceMappingURL=transformStatement.js.map

package/out/TSTransformer/nodes/statements/transformSwitchStatement.d.ts

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

package/out/TSTransformer/nodes/statements/transformSwitchStatement.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSwitchStatement = transformSwitchStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformStatementList_1 = require("../transformStatementList");
+const createHoistDeclaration_1 = require("../../util/createHoistDeclaration");
+const typescript_1 = __importDefault(require("typescript"));
+function transformCaseClauseExpression(state, caseClauseExpression, switchExpression, fallThroughFlagId, canFallThroughTo) {
+    let [expression, prereqStatements] = state.capture(() => (0, transformExpression_1.transformExpression)(state, caseClauseExpression));
+    expression = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, { expression });
+    let condition = luau_ast_1.default.binary(switchExpression, "==", expression);
+    if (canFallThroughTo) {
+        if (!luau_ast_1.default.list.isEmpty(prereqStatements)) {
+            const noFallThroughCondition = luau_ast_1.default.unary("not", fallThroughFlagId);
+            luau_ast_1.default.list.push(prereqStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: fallThroughFlagId,
+                operator: "=",
+                right: condition,
+            }));
+            prereqStatements = luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+                condition: noFallThroughCondition,
+                statements: prereqStatements,
+                elseBody: luau_ast_1.default.list.make(),
+            }));
+            condition = fallThroughFlagId;
+        }
+        else {
+            condition = luau_ast_1.default.binary(fallThroughFlagId, "or", condition);
+        }
+    }
+    return {
+        condition,
+        prereqStatements,
+    };
+}
+function transformCaseClause(state, node, switchExpression, fallThroughFlagId, canFallThroughTo, shouldUpdateFallThroughFlag) {
+    const { condition, prereqStatements } = transformCaseClauseExpression(state, node.expression, switchExpression, fallThroughFlagId, canFallThroughTo);
+    const nonEmptyStatements = node.statements.filter(v => !typescript_1.default.isEmptyStatement(v));
+    const firstStatement = nonEmptyStatements[0];
+    const statements = nonEmptyStatements.length === 1 && typescript_1.default.isBlock(firstStatement)
+        ? (0, transformStatementList_1.transformStatementList)(state, firstStatement, firstStatement.statements)
+        : (0, transformStatementList_1.transformStatementList)(state, node, node.statements);
+    const canFallThroughFrom = statements.tail === undefined || !luau_ast_1.default.isFinalStatement(statements.tail.value);
+    if (canFallThroughFrom && shouldUpdateFallThroughFlag) {
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: fallThroughFlagId,
+            operator: "=",
+            right: luau_ast_1.default.bool(true),
+        }));
+    }
+    const clauseStatements = luau_ast_1.default.list.make();
+    const hoistDeclaration = (0, createHoistDeclaration_1.createHoistDeclaration)(state, node);
+    if (hoistDeclaration) {
+        luau_ast_1.default.list.push(clauseStatements, hoistDeclaration);
+    }
+    luau_ast_1.default.list.push(clauseStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition,
+        statements,
+        elseBody: luau_ast_1.default.list.make(),
+    }));
+    return {
+        canFallThroughFrom,
+        prereqs: prereqStatements,
+        clauseStatements,
+    };
+}
+function transformSwitchStatement(state, node) {
+    const expression = state.pushToVarIfComplex((0, transformExpression_1.transformExpression)(state, node.expression), "exp");
+    const fallThroughFlagId = luau_ast_1.default.tempId("fallthrough");
+    let isFallThroughFlagNeeded = false;
+    const statements = luau_ast_1.default.list.make();
+    let canFallThroughTo = false;
+    for (let i = 0; i < node.caseBlock.clauses.length; i++) {
+        const caseClauseNode = node.caseBlock.clauses[i];
+        if (typescript_1.default.isCaseClause(caseClauseNode)) {
+            const shouldUpdateFallThroughFlag = i < node.caseBlock.clauses.length - 1 && typescript_1.default.isCaseClause(node.caseBlock.clauses[i + 1]);
+            const { canFallThroughFrom, prereqs, clauseStatements } = transformCaseClause(state, caseClauseNode, expression, fallThroughFlagId, canFallThroughTo, shouldUpdateFallThroughFlag);
+            luau_ast_1.default.list.pushList(statements, prereqs);
+            luau_ast_1.default.list.pushList(statements, clauseStatements);
+            canFallThroughTo = canFallThroughFrom;
+            if (canFallThroughFrom) {
+                isFallThroughFlagNeeded = true;
+            }
+        }
+        else {
+            luau_ast_1.default.list.pushList(statements, (0, transformStatementList_1.transformStatementList)(state, caseClauseNode, caseClauseNode.statements));
+            break;
+        }
+    }
+    if (isFallThroughFlagNeeded) {
+        luau_ast_1.default.list.unshift(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: fallThroughFlagId,
+            right: luau_ast_1.default.bool(false),
+        }));
+    }
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.RepeatStatement, {
+        condition: luau_ast_1.default.bool(true),
+        statements,
+    }));
+}
+//# sourceMappingURL=transformSwitchStatement.js.map

package/out/TSTransformer/nodes/statements/transformThrowStatement.d.ts

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

package/out/TSTransformer/nodes/statements/transformThrowStatement.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.transformThrowStatement = transformThrowStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("../expressions/transformExpression");
+function transformThrowStatement(state, node) {
+    const args = new Array();
+    if (node.expression !== undefined) {
+        args.push((0, transformExpression_1.transformExpression)(state, node.expression));
+    }
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+        expression: luau_ast_1.default.call(luau_ast_1.default.globals.error, args),
+    }));
+}
+//# sourceMappingURL=transformThrowStatement.js.map

package/out/TSTransformer/nodes/statements/transformTryStatement.d.ts

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

package/out/TSTransformer/nodes/statements/transformTryStatement.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTryStatement = transformTryStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const transformBindingName_1 = require("../binding/transformBindingName");
+const transformStatementList_1 = require("../transformStatementList");
+const isBlockedByTryStatement_1 = require("../../util/isBlockedByTryStatement");
+function transformCatchClause(state, node) {
+    const parameters = luau_ast_1.default.list.make();
+    const statements = luau_ast_1.default.list.make();
+    if (node.variableDeclaration) {
+        luau_ast_1.default.list.push(parameters, (0, transformBindingName_1.transformBindingName)(state, node.variableDeclaration.name, statements));
+    }
+    luau_ast_1.default.list.pushList(statements, (0, transformStatementList_1.transformStatementList)(state, node.block, node.block.statements));
+    const catchFunction = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+        parameters,
+        hasDotDotDot: false,
+        statements,
+    });
+    return catchFunction;
+}
+function transformIntoTryCall(state, node, exitTypeId, returnsId, tryUses) {
+    const tryCallArgs = new Array();
+    tryCallArgs.push(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+        parameters: luau_ast_1.default.list.make(),
+        hasDotDotDot: false,
+        statements: (0, transformStatementList_1.transformStatementList)(state, node.tryBlock, node.tryBlock.statements),
+    }));
+    if (node.catchClause) {
+        tryCallArgs.push(transformCatchClause(state, node.catchClause));
+    }
+    else {
+        (0, assert_1.assert)(node.finallyBlock);
+        tryCallArgs.push(luau_ast_1.default.nil());
+    }
+    if (node.finallyBlock) {
+        tryCallArgs.push(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.FunctionExpression, {
+            parameters: luau_ast_1.default.list.make(),
+            hasDotDotDot: false,
+            statements: (0, transformStatementList_1.transformStatementList)(state, node.finallyBlock, node.finallyBlock.statements),
+        }));
+    }
+    if (!tryUses.usesReturn && !tryUses.usesBreak && !tryUses.usesContinue) {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: luau_ast_1.default.call(state.TS(node, "try"), tryCallArgs),
+        });
+    }
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: luau_ast_1.default.list.make(exitTypeId, returnsId),
+        right: luau_ast_1.default.call(state.TS(node, "try"), tryCallArgs),
+    });
+}
+function createFlowControlCondition(state, node, exitTypeId, flowControlConstant) {
+    return luau_ast_1.default.binary(exitTypeId, "==", state.TS(node, flowControlConstant));
+}
+function collapseFlowControlCases(exitTypeId, cases) {
+    (0, assert_1.assert)(cases.length > 0);
+    let nextStatements = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: exitTypeId,
+        statements: cases[cases.length - 1].statements,
+        elseBody: luau_ast_1.default.list.make(),
+    });
+    for (let i = cases.length - 2; i >= 0; i--) {
+        nextStatements = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: cases[i].condition || exitTypeId,
+            statements: cases[i].statements,
+            elseBody: nextStatements,
+        });
+    }
+    return luau_ast_1.default.list.make(nextStatements);
+}
+function transformFlowControl(state, node, exitTypeId, returnsId, tryUses) {
+    const flowControlCases = new Array();
+    if (!tryUses.usesReturn && !tryUses.usesBreak && !tryUses.usesContinue) {
+        return luau_ast_1.default.list.make();
+    }
+    const returnBlocked = (0, isBlockedByTryStatement_1.isReturnBlockedByTryStatement)(node.parent);
+    const breakBlocked = (0, isBlockedByTryStatement_1.isBreakBlockedByTryStatement)(node.parent);
+    if (tryUses.usesReturn && returnBlocked) {
+        state.markTryUses("usesReturn");
+    }
+    if (tryUses.usesBreak && breakBlocked) {
+        state.markTryUses("usesBreak");
+    }
+    if (tryUses.usesContinue && breakBlocked) {
+        state.markTryUses("usesContinue");
+    }
+    if (tryUses.usesReturn) {
+        if (returnBlocked) {
+            flowControlCases.push({
+                condition: createFlowControlCondition(state, node, exitTypeId, "TRY_RETURN"),
+                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                    expression: luau_ast_1.default.list.make(exitTypeId, returnsId),
+                })),
+            });
+            if (breakBlocked) {
+                return collapseFlowControlCases(exitTypeId, flowControlCases);
+            }
+        }
+        else {
+            flowControlCases.push({
+                condition: createFlowControlCondition(state, node, exitTypeId, "TRY_RETURN"),
+                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                    expression: luau_ast_1.default.call(luau_ast_1.default.globals.unpack, [returnsId]),
+                })),
+            });
+        }
+    }
+    if (tryUses.usesBreak || tryUses.usesContinue) {
+        if (breakBlocked) {
+            flowControlCases.push({
+                statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+                    expression: exitTypeId,
+                })),
+            });
+        }
+        else {
+            if (tryUses.usesBreak) {
+                flowControlCases.push({
+                    condition: createFlowControlCondition(state, node, exitTypeId, "TRY_BREAK"),
+                    statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
+                });
+            }
+            if (tryUses.usesContinue) {
+                flowControlCases.push({
+                    condition: createFlowControlCondition(state, node, exitTypeId, "TRY_CONTINUE"),
+                    statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ContinueStatement, {})),
+                });
+            }
+        }
+    }
+    return collapseFlowControlCases(exitTypeId, flowControlCases);
+}
+function transformTryStatement(state, node) {
+    const statements = luau_ast_1.default.list.make();
+    const exitTypeId = luau_ast_1.default.tempId("exitType");
+    const returnsId = luau_ast_1.default.tempId("returns");
+    const tryUses = state.pushTryUsesStack();
+    luau_ast_1.default.list.push(statements, transformIntoTryCall(state, node, exitTypeId, returnsId, tryUses));
+    state.popTryUsesStack();
+    luau_ast_1.default.list.pushList(statements, transformFlowControl(state, node, exitTypeId, returnsId, tryUses));
+    return statements;
+}
+//# sourceMappingURL=transformTryStatement.js.map

package/out/TSTransformer/nodes/statements/transformVariableStatement.d.ts

@@ -0,0 +1,8 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformVariable(state: TransformState, identifier: ts.Identifier, right?: luau.Expression): luau.AnyIdentifier | luau.PropertyAccessExpression;
+export declare function transformVariableDeclaration(state: TransformState, node: ts.VariableDeclaration): luau.List<luau.Statement>;
+export declare function isVarDeclaration(node: ts.VariableDeclarationList): boolean;
+export declare function transformVariableDeclarationList(state: TransformState, node: ts.VariableDeclarationList): luau.List<luau.Statement>;
+export declare function transformVariableStatement(state: TransformState, node: ts.VariableStatement): luau.List<luau.Statement>;