@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/transformWritable.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformWritableExpression = transformWritableExpression;
+exports.transformWritableAssignment = transformWritableAssignment;
+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 transformExpression_1 = require("./expressions/transformExpression");
+const addOneIfArrayType_1 = require("../util/addOneIfArrayType");
+const convertToIndexableExpression_1 = require("../util/convertToIndexableExpression");
+const ensureTransformOrder_1 = require("../util/ensureTransformOrder");
+const traversal_1 = require("../util/traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function transformWritableExpression(state, node, readAfterWrite) {
+    if (typescript_1.default.isPrototypeAccess(node)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrototype(node));
+    }
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        const expression = (0, transformExpression_1.transformExpression)(state, node.expression);
+        return luau_ast_1.default.property(readAfterWrite ? state.pushToVarIfNonId(expression, "exp") : (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), node.name.text);
+    }
+    else if (typescript_1.default.isElementAccessExpression(node)) {
+        const [expression, index] = (0, ensureTransformOrder_1.ensureTransformOrder)(state, [node.expression, node.argumentExpression]);
+        const indexExp = (0, addOneIfArrayType_1.addOneIfArrayType)(state, state.getType(node.expression), index);
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: readAfterWrite
+                ? state.pushToVarIfNonId(expression, "exp")
+                : (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression),
+            index: readAfterWrite ? state.pushToVarIfComplex(indexExp, "index") : indexExp,
+        });
+    }
+    else {
+        const transformed = (0, transformExpression_1.transformExpression)(state, (0, traversal_1.skipDownwards)(node));
+        (0, assert_1.assert)(luau_ast_1.default.isWritableExpression(transformed));
+        return transformed;
+    }
+}
+function transformWritableAssignment(state, writeNode, valueNode, readAfterWrite = false, readBeforeWrite = false) {
+    const writable = transformWritableExpression(state, writeNode, readAfterWrite);
+    const [value, prereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, valueNode));
+    const readable = !readBeforeWrite || luau_ast_1.default.list.isEmpty(prereqs) ? writable : state.pushToVar(writable, "readable");
+    state.prereqList(prereqs);
+    return { writable, readable, value };
+}
+//# sourceMappingURL=transformWritable.js.map

package/out/TSTransformer/typeGuards.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export declare function isBlockLike(node: ts.Node): node is ts.BlockLike;
+export declare function isUnaryAssignmentOperator(operator: ts.SyntaxKind): operator is ts.SyntaxKind.PlusPlusToken | ts.SyntaxKind.MinusMinusToken;
+export declare function isTemplateLiteralType(type: ts.Type): type is ts.TemplateLiteralType;
+export declare function isNamespace(node: ts.Node): node is ts.ModuleDeclaration;

package/out/TSTransformer/typeGuards.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlockLike = isBlockLike;
+exports.isUnaryAssignmentOperator = isUnaryAssignmentOperator;
+exports.isTemplateLiteralType = isTemplateLiteralType;
+exports.isNamespace = isNamespace;
+const typescript_1 = __importDefault(require("typescript"));
+function isBlockLike(node) {
+    return (node.kind === typescript_1.default.SyntaxKind.SourceFile ||
+        node.kind === typescript_1.default.SyntaxKind.Block ||
+        node.kind === typescript_1.default.SyntaxKind.ModuleBlock ||
+        node.kind === typescript_1.default.SyntaxKind.CaseClause ||
+        node.kind === typescript_1.default.SyntaxKind.DefaultClause);
+}
+function isUnaryAssignmentOperator(operator) {
+    return operator === typescript_1.default.SyntaxKind.PlusPlusToken || operator === typescript_1.default.SyntaxKind.MinusMinusToken;
+}
+function isTemplateLiteralType(type) {
+    return "texts" in type && "types" in type && !!(type.flags & typescript_1.default.TypeFlags.TemplateLiteral);
+}
+function isNamespace(node) {
+    return typescript_1.default.isModuleDeclaration(node) && !!(node.flags & typescript_1.default.NodeFlags.Namespace);
+}
+//# sourceMappingURL=typeGuards.js.map

package/out/TSTransformer/types.d.ts

@@ -0,0 +1,9 @@
+import { MacroManager } from "./";
+export interface TransformServices {
+    macroManager: MacroManager;
+}
+export interface TryUses {
+    usesReturn: boolean;
+    usesBreak: boolean;
+    usesContinue: boolean;
+}

package/out/TSTransformer/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/out/TSTransformer/util/addIndexDiagnostics.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function addIndexDiagnostics(state: TransformState, node: ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.SignatureDeclarationBase | ts.PropertyName, expType: ts.Type): void;

package/out/TSTransformer/util/addIndexDiagnostics.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIndexDiagnostics = addIndexDiagnostics;
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const isMethod_1 = require("./isMethod");
+const isValidMethodIndexWithoutCall_1 = require("./isValidMethodIndexWithoutCall");
+const traversal_1 = require("./traversal");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+function addIndexDiagnostics(state, node, expType) {
+    const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+    if ((symbol && state.services.macroManager.getPropertyCallMacro(symbol)) ||
+        (!(0, isValidMethodIndexWithoutCall_1.isValidMethodIndexWithoutCall)(state, (0, traversal_1.skipUpwards)(node)) && (0, isMethod_1.isMethod)(state, node))) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noIndexWithoutCall(node));
+    }
+    if (typescript_1.default.isPrototypeAccess(node)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrototype(node));
+    }
+}
+//# sourceMappingURL=addIndexDiagnostics.js.map

package/out/TSTransformer/util/addOneIfArrayType.d.ts

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

package/out/TSTransformer/util/addOneIfArrayType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOneIfArrayType = addOneIfArrayType;
+const offset_1 = require("./offset");
+const types_1 = require("./types");
+function addOneIfArrayType(state, type, expression) {
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isArrayType)(state), types_1.isUndefinedType)) {
+        return (0, offset_1.offset)(expression, 1);
+    }
+    else {
+        return expression;
+    }
+}
+//# sourceMappingURL=addOneIfArrayType.js.map

package/out/TSTransformer/util/arrayBindingPatternContainsHoists.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function arrayBindingPatternContainsHoists(state: TransformState, arrayBindingPattern: ts.ArrayBindingPattern): boolean;

package/out/TSTransformer/util/arrayBindingPatternContainsHoists.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBindingPatternContainsHoists = arrayBindingPatternContainsHoists;
+const checkVariableHoist_1 = require("./checkVariableHoist");
+const typescript_1 = __importDefault(require("typescript"));
+function arrayBindingPatternContainsHoists(state, arrayBindingPattern) {
+    for (const element of arrayBindingPattern.elements) {
+        if (typescript_1.default.isBindingElement(element) && typescript_1.default.isIdentifier(element.name)) {
+            const symbol = state.typeChecker.getSymbolAtLocation(element.name);
+            if (symbol) {
+                (0, checkVariableHoist_1.checkVariableHoist)(state, element.name, symbol);
+                if (state.isHoisted.get(symbol)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=arrayBindingPatternContainsHoists.js.map

package/out/TSTransformer/util/arrayLikeExpressionContainsSpread.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function arrayLikeExpressionContainsSpread(exp: ts.ArrayBindingPattern | ts.ArrayLiteralExpression): boolean;

package/out/TSTransformer/util/arrayLikeExpressionContainsSpread.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayLikeExpressionContainsSpread = arrayLikeExpressionContainsSpread;
+const typescript_1 = __importDefault(require("typescript"));
+function arrayLikeExpressionContainsSpread(exp) {
+    for (const element of exp.elements) {
+        if ((typescript_1.default.isBindingElement(element) && element.dotDotDotToken) || typescript_1.default.isSpreadElement(element))
+            return true;
+        if (typescript_1.default.isArrayBindingPattern(element) && arrayLikeExpressionContainsSpread(element))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=arrayLikeExpressionContainsSpread.js.map

package/out/TSTransformer/util/assertNever.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(value: never, message: string): never;

package/out/TSTransformer/util/assertNever.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNever = assertNever;
+const child_process_1 = require("child_process");
+const kleur_1 = __importDefault(require("kleur"));
+const LogService_1 = require("../../Shared/classes/LogService");
+const getKindName_1 = require("./getKindName");
+const typescript_1 = __importDefault(require("typescript"));
+const util_1 = __importDefault(require("util"));
+function findTypescriptVersion(info) {
+    if (info.name === "roblox-ts" && info.dependencies.typescript) {
+        return info.dependencies.typescript.version;
+    }
+    for (const [, dep] of Object.entries(info.dependencies)) {
+        const found = findTypescriptVersion(dep);
+        if (found) {
+            return found;
+        }
+    }
+}
+function error(message) {
+    const typescriptVersion = findTypescriptVersion(JSON.parse((0, child_process_1.spawnSync)("npm ls typescript --json").stdout.toString()));
+    LogService_1.LogService.fatal(kleur_1.default.red(`Exhaustive assertion failed! ${message}`) +
+        kleur_1.default.yellow("\nThis is usually caused by a TypeScript version mismatch.") +
+        kleur_1.default.yellow("\nMake sure that all TS versions in your project are the same.") +
+        kleur_1.default.yellow("\nYou can check the list of installed versions with `npm list typescript`") +
+        (typescriptVersion ? kleur_1.default.yellow(`\nTry running \`npm install typescript@=${typescriptVersion}\``) : ""));
+}
+function assertNever(value, message) {
+    const isTsNode = typeof value === "object" && "kind" in value && typescript_1.default.isNode(value);
+    error(`${message}, value was ${isTsNode ? `a TS node of kind ${(0, getKindName_1.getKindName)(value.kind)}` : util_1.default.inspect(value)}`);
+}
+//# sourceMappingURL=assertNever.js.map

package/out/TSTransformer/util/assignment.d.ts

@@ -0,0 +1,7 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function getSimpleAssignmentOperator(leftType: ts.Type, operatorKind: ts.AssignmentOperator, rightType: ts.Type): luau.AssignmentOperator | undefined;
+export declare function createAssignmentExpression(state: TransformState, readable: luau.WritableExpression, operator: luau.AssignmentOperator, value: luau.Expression): luau.WritableExpression;
+export declare function createCompoundAssignmentStatement(state: TransformState, node: ts.Node, writable: luau.WritableExpression, writableType: ts.Type, readable: luau.WritableExpression, operator: ts.BinaryOperator, value: luau.Expression, valueType: ts.Type): luau.Assignment;
+export declare function createCompoundAssignmentExpression(state: TransformState, node: ts.Node, writable: luau.WritableExpression, writableType: ts.Type, readable: luau.WritableExpression, operator: ts.BinaryOperator, value: luau.Expression, valueType: ts.Type): luau.WritableExpression;

package/out/TSTransformer/util/assignment.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSimpleAssignmentOperator = getSimpleAssignmentOperator;
+exports.createAssignmentExpression = createAssignmentExpression;
+exports.createCompoundAssignmentStatement = createCompoundAssignmentStatement;
+exports.createCompoundAssignmentExpression = createCompoundAssignmentExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const createBinaryFromOperator_1 = require("./createBinaryFromOperator");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+const COMPOUND_OPERATOR_MAP = new Map([
+    [typescript_1.default.SyntaxKind.MinusEqualsToken, "-="],
+    [typescript_1.default.SyntaxKind.AsteriskEqualsToken, "*="],
+    [typescript_1.default.SyntaxKind.SlashEqualsToken, "/="],
+    [typescript_1.default.SyntaxKind.AsteriskAsteriskEqualsToken, "^="],
+    [typescript_1.default.SyntaxKind.PercentEqualsToken, "%="],
+    [typescript_1.default.SyntaxKind.PlusPlusToken, "+="],
+    [typescript_1.default.SyntaxKind.MinusMinusToken, "-="],
+    [typescript_1.default.SyntaxKind.EqualsToken, "="],
+]);
+function getSimpleAssignmentOperator(leftType, operatorKind, rightType) {
+    if (operatorKind === typescript_1.default.SyntaxKind.PlusEqualsToken) {
+        return (0, types_1.isDefinitelyType)(leftType, types_1.isStringType) || (0, types_1.isDefinitelyType)(rightType, types_1.isStringType) ? "..=" : "+=";
+    }
+    return COMPOUND_OPERATOR_MAP.get(operatorKind);
+}
+function createAssignmentExpression(state, readable, operator, value) {
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: readable,
+        operator,
+        right: value,
+    }));
+    return readable;
+}
+function createCompoundAssignmentStatement(state, node, writable, writableType, readable, operator, value, valueType) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator: "=",
+        right: (0, createBinaryFromOperator_1.createBinaryFromOperator)(state, node, readable, writableType, operator, value, valueType),
+    });
+}
+function createCompoundAssignmentExpression(state, node, writable, writableType, readable, operator, value, valueType) {
+    return createAssignmentExpression(state, writable, "=", (0, createBinaryFromOperator_1.createBinaryFromOperator)(state, node, readable, writableType, operator, value, valueType));
+}
+//# sourceMappingURL=assignment.js.map

package/out/TSTransformer/util/binding/getAccessorForBindingType.d.ts

@@ -0,0 +1,6 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+type BindingAccessor = (state: TransformState, parentId: luau.AnyIdentifier, index: number, idStack: Array<luau.AnyIdentifier>, isOmitted: boolean) => luau.Expression;
+export declare function getAccessorForBindingType(state: TransformState, node: ts.Node, type: ts.Type): BindingAccessor;
+export {};

package/out/TSTransformer/util/binding/getAccessorForBindingType.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessorForBindingType = getAccessorForBindingType;
+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 types_1 = require("../types");
+const typescript_1 = __importDefault(require("typescript"));
+function peek(array) {
+    return array[array.length - 1];
+}
+const arrayAccessor = (state, parentId, index) => {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+        expression: parentId,
+        index: luau_ast_1.default.number(index + 1),
+    });
+};
+const stringAccessor = (state, parentId, index, idStack, isOmitted) => {
+    let id;
+    if (idStack.length === 0) {
+        id = state.pushToVar(luau_ast_1.default.call(luau_ast_1.default.globals.string.gmatch, [parentId, luau_ast_1.default.globals.utf8.charpattern]), "matcher");
+        idStack.push(id);
+    }
+    else {
+        id = idStack[0];
+    }
+    const callExp = luau_ast_1.default.call(id);
+    if (isOmitted) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: callExp,
+        }));
+        return luau_ast_1.default.none();
+    }
+    else {
+        return callExp;
+    }
+};
+const setAccessor = (state, parentId, index, idStack, isOmitted) => {
+    const args = [parentId];
+    const lastId = peek(idStack);
+    if (lastId) {
+        args.push(lastId);
+    }
+    const callExp = luau_ast_1.default.call(luau_ast_1.default.globals.next, args);
+    if (isOmitted) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: callExp,
+        }));
+        return luau_ast_1.default.none();
+    }
+    else {
+        const id = state.pushToVar(callExp, "value");
+        idStack.push(id);
+        return id;
+    }
+};
+const mapAccessor = (state, parentId, index, idStack) => {
+    const args = [parentId];
+    const lastId = peek(idStack);
+    if (lastId) {
+        args.push(lastId);
+    }
+    const keyId = luau_ast_1.default.tempId("k");
+    const valueId = luau_ast_1.default.tempId("v");
+    const ids = luau_ast_1.default.list.make(keyId, valueId);
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: ids,
+        right: luau_ast_1.default.call(luau_ast_1.default.globals.next, args),
+    }));
+    idStack.push(keyId);
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Array, { members: ids });
+};
+const iterableFunctionLuaTupleAccessor = (state, parentId, index, idStack, isOmitted) => {
+    const callExp = luau_ast_1.default.call(parentId);
+    if (isOmitted) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: callExp,
+        }));
+        return luau_ast_1.default.none();
+    }
+    else {
+        return luau_ast_1.default.array([callExp]);
+    }
+};
+const iterableFunctionAccessor = (state, parentId, index, idStack, isOmitted) => {
+    const callExp = luau_ast_1.default.call(parentId);
+    if (isOmitted) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+            expression: callExp,
+        }));
+        return luau_ast_1.default.none();
+    }
+    else {
+        return callExp;
+    }
+};
+const iterAccessor = (state, parentId, index, idStack, isOmitted) => {
+    const callExp = luau_ast_1.default.call(luau_ast_1.default.property(parentId, "next"));
+    if (isOmitted) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, { expression: callExp }));
+        return luau_ast_1.default.none();
+    }
+    else {
+        return luau_ast_1.default.property(callExp, "value");
+    }
+};
+function getAccessorForBindingType(state, node, type) {
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isArrayType)(state))) {
+        return arrayAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, types_1.isStringType)) {
+        return stringAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isSetType)(state))) {
+        return setAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isMapType)(state)) || (0, types_1.isDefinitelyType)(type, (0, types_1.isSharedTableType)(state))) {
+        return mapAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isIterableFunctionLuaTupleType)(state))) {
+        return iterableFunctionLuaTupleAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isIterableFunctionType)(state))) {
+        return iterableFunctionAccessor;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isIterableType)(state))) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noIterableIteration(node));
+        return () => luau_ast_1.default.none();
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isGeneratorType)(state)) ||
+        (0, types_1.isDefinitelyType)(type, types_1.isObjectType) ||
+        typescript_1.default.isThis(node)) {
+        return iterAccessor;
+    }
+    (0, assert_1.assert)(false, `Destructuring not supported for type: ${state.typeChecker.typeToString(type)}`);
+}
+//# sourceMappingURL=getAccessorForBindingType.js.map

package/out/TSTransformer/util/binding/getTargetIdForBindingPattern.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+import ts from "typescript";
+export declare function getTargetIdForBindingPattern(state: TransformState, name: ts.BindingPattern, value: luau.Expression): luau.Identifier | luau.TemporaryIdentifier;

package/out/TSTransformer/util/binding/getTargetIdForBindingPattern.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetIdForBindingPattern = getTargetIdForBindingPattern;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const typescript_1 = __importDefault(require("typescript"));
+function getTargetIdForBindingPattern(state, name, value) {
+    return luau_ast_1.default.isAnyIdentifier(value) &&
+        name.elements.every(element => typescript_1.default.isOmittedExpression(element) || !element.initializer)
+        ? value
+        : state.pushToVar(value, "binding");
+}
+//# sourceMappingURL=getTargetIdForBindingPattern.js.map

package/out/TSTransformer/util/binding/objectAccessor.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare const objectAccessor: (state: TransformState, parentId: luau.AnyIdentifier, type: ts.Type, name: ts.PropertyName) => luau.Expression;

package/out/TSTransformer/util/binding/objectAccessor.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectAccessor = void 0;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../../nodes/expressions/transformExpression");
+const addIndexDiagnostics_1 = require("../addIndexDiagnostics");
+const addOneIfArrayType_1 = require("../addOneIfArrayType");
+const assertNever_1 = require("../assertNever");
+const typescript_1 = __importDefault(require("typescript"));
+const objectAccessor = (state, parentId, type, name) => {
+    (0, addIndexDiagnostics_1.addIndexDiagnostics)(state, name, state.getType(name));
+    if (typescript_1.default.isIdentifier(name)) {
+        return luau_ast_1.default.property(parentId, name.text);
+    }
+    else if (typescript_1.default.isComputedPropertyName(name)) {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: parentId,
+            index: (0, addOneIfArrayType_1.addOneIfArrayType)(state, type, (0, transformExpression_1.transformExpression)(state, name.expression)),
+        });
+    }
+    else if (typescript_1.default.isNumericLiteral(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNoSubstitutionTemplateLiteral(name)) {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+            expression: parentId,
+            index: (0, transformExpression_1.transformExpression)(state, name),
+        });
+    }
+    else if (typescript_1.default.isPrivateIdentifier(name)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrivateIdentifier(name));
+        return luau_ast_1.default.none();
+    }
+    return (0, assertNever_1.assertNever)(name, "objectAccessor");
+};
+exports.objectAccessor = objectAccessor;
+//# sourceMappingURL=objectAccessor.js.map

package/out/TSTransformer/util/bitwise.d.ts

@@ -0,0 +1,6 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function isBitwiseOperator(operatorKind: ts.BinaryOperator): boolean;
+export declare function createBitwiseCall(operatorKind: ts.BinaryOperator, expressions: Array<luau.Expression>): luau.Expression;
+export declare function createBitwiseFromOperator(state: TransformState, operatorKind: ts.BinaryOperator, node: ts.BinaryExpression): luau.Expression;

package/out/TSTransformer/util/bitwise.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBitwiseOperator = isBitwiseOperator;
+exports.createBitwiseCall = createBitwiseCall;
+exports.createBitwiseFromOperator = createBitwiseFromOperator;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../Shared/util/assert");
+const ensureTransformOrder_1 = require("./ensureTransformOrder");
+const getKindName_1 = require("./getKindName");
+const traversal_1 = require("./traversal");
+const typescript_1 = __importDefault(require("typescript"));
+const OPERATOR_MAP = new Map([
+    [typescript_1.default.SyntaxKind.LessThanLessThanToken, "lshift"],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, "rshift"],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanToken, "arshift"],
+    [typescript_1.default.SyntaxKind.AmpersandEqualsToken, "band"],
+    [typescript_1.default.SyntaxKind.BarEqualsToken, "bor"],
+    [typescript_1.default.SyntaxKind.CaretEqualsToken, "bxor"],
+    [typescript_1.default.SyntaxKind.LessThanLessThanEqualsToken, "lshift"],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, "rshift"],
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanEqualsToken, "arshift"],
+]);
+const LOGICAL_OPERATOR_MAP = new Map([
+    [typescript_1.default.SyntaxKind.AmpersandToken, "band"],
+    [typescript_1.default.SyntaxKind.BarToken, "bor"],
+    [typescript_1.default.SyntaxKind.CaretToken, "bxor"],
+]);
+function flattenBitwiseSegmentInto(expressionList, operatorKind, node) {
+    if (typescript_1.default.isBinaryExpression(node)) {
+        if (operatorKind === node.operatorToken.kind) {
+            flattenBitwiseSegmentInto(expressionList, operatorKind, node.left);
+            expressionList.push((0, traversal_1.skipDownwards)(node.right));
+        }
+        else {
+            expressionList.push(node);
+        }
+        return;
+    }
+    expressionList.push((0, traversal_1.skipDownwards)(node));
+}
+function isBitwiseLogicalOperator(operatorKind) {
+    return LOGICAL_OPERATOR_MAP.has(operatorKind);
+}
+function isBitwiseOperator(operatorKind) {
+    return OPERATOR_MAP.has(operatorKind) || isBitwiseLogicalOperator(operatorKind);
+}
+function createBitwiseCall(operatorKind, expressions) {
+    var _a;
+    const name = (_a = OPERATOR_MAP.get(operatorKind)) !== null && _a !== void 0 ? _a : LOGICAL_OPERATOR_MAP.get(operatorKind);
+    (0, assert_1.assert)(name !== undefined, `createBitwiseFromOperator unknown operator: ${(0, getKindName_1.getKindName)(operatorKind)}`);
+    return luau_ast_1.default.call(luau_ast_1.default.property(luau_ast_1.default.globals.bit32, name), expressions);
+}
+function createBitwiseFromOperator(state, operatorKind, node) {
+    const flattenedExpressions = new Array();
+    if (isBitwiseLogicalOperator(operatorKind)) {
+        flattenBitwiseSegmentInto(flattenedExpressions, operatorKind, node.left);
+        flattenedExpressions.push(node.right);
+    }
+    else {
+        flattenedExpressions.push(node.left, node.right);
+    }
+    return createBitwiseCall(operatorKind, (0, ensureTransformOrder_1.ensureTransformOrder)(state, flattenedExpressions));
+}
+//# sourceMappingURL=bitwise.js.map

package/out/TSTransformer/util/checkVariableHoist.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function checkVariableHoist(state: TransformState, node: ts.Identifier, symbol: ts.Symbol): void;

package/out/TSTransformer/util/checkVariableHoist.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkVariableHoist = checkVariableHoist;
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+const traversal_1 = require("./traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function checkVariableHoist(state, node, symbol) {
+    if (state.isHoisted.get(symbol) !== undefined) {
+        return;
+    }
+    const statement = (0, traversal_1.getAncestor)(node, typescript_1.default.isStatement);
+    if (!statement) {
+        return;
+    }
+    const caseClause = statement.parent;
+    if (!typescript_1.default.isCaseClause(caseClause)) {
+        return;
+    }
+    const caseBlock = caseClause.parent;
+    const isUsedOutsideOfCaseClause = typescript_1.default.FindAllReferences.Core.eachSymbolReferenceInFile(node, state.typeChecker, node.getSourceFile(), token => {
+        if (!(0, traversal_1.isAncestorOf)(caseClause, token)) {
+            return true;
+        }
+    }, caseBlock) === true;
+    if (isUsedOutsideOfCaseClause) {
+        (0, getOrSetDefault_1.getOrSetDefault)(state.hoistsByStatement, statement.parent, () => new Array()).push(node);
+        state.isHoisted.set(symbol, true);
+    }
+}
+//# sourceMappingURL=checkVariableHoist.js.map

package/out/TSTransformer/util/cleanModuleName.d.ts

@@ -0,0 +1 @@
+export declare function cleanModuleName(name: string): string;