@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/classes/TransformState.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformState = void 0;
+const luau_ast_1 = __importStar(require("@roblox-ts/luau-ast"));
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../Shared/constants");
+const diagnostics_1 = require("../../Shared/diagnostics");
+const assert_1 = require("../../Shared/util/assert");
+const getCanonicalFileName_1 = require("../../Shared/util/getCanonicalFileName");
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+const DiagnosticService_1 = require("./DiagnosticService");
+const createGetService_1 = require("../util/createGetService");
+const expressionChain_1 = require("../util/expressionChain");
+const traversal_1 = require("../util/traversal");
+const valueToIdStr_1 = require("../util/valueToIdStr");
+const typescript_1 = __importDefault(require("typescript"));
+class TransformState {
+    debugRender(node) {
+        const state = new luau_ast_1.RenderState();
+        (0, luau_ast_1.solveTempIds)(state, node);
+        return (0, luau_ast_1.render)(state, node);
+    }
+    debugRenderList(list) {
+        const state = new luau_ast_1.RenderState();
+        (0, luau_ast_1.solveTempIds)(state, list);
+        return (0, luau_ast_1.renderStatements)(state, list);
+    }
+    constructor(program, data, services, pathTranslator, multiTransformState, compilerOptions, rojoResolver, pkgRojoResolvers, nodeModulesPathMapping, runtimeLibRbxPath, typeChecker, projectType, getProjectPathTranslator, sourceFile) {
+        this.program = program;
+        this.data = data;
+        this.services = services;
+        this.pathTranslator = pathTranslator;
+        this.multiTransformState = multiTransformState;
+        this.compilerOptions = compilerOptions;
+        this.rojoResolver = rojoResolver;
+        this.pkgRojoResolvers = pkgRojoResolvers;
+        this.nodeModulesPathMapping = nodeModulesPathMapping;
+        this.runtimeLibRbxPath = runtimeLibRbxPath;
+        this.typeChecker = typeChecker;
+        this.projectType = projectType;
+        this.getProjectPathTranslator = getProjectPathTranslator;
+        this.hasExportEquals = false;
+        this.hasExportFrom = false;
+        this.classIdentifierMap = new Map();
+        this.tryUsesStack = new Array();
+        this.prereqStatementsStack = new Array();
+        this.hoistsByStatement = new Map();
+        this.isHoisted = new Map();
+        this.getTypeCache = new Map();
+        this.usesRuntimeLib = false;
+        this.moduleIdBySymbol = new Map();
+        this.symbolToIdMap = new Map();
+        this.classElementToObjectKeyMap = new Map();
+        this.sourceFileText = sourceFile.getFullText();
+        this.resolver = typeChecker.getEmitResolver(sourceFile);
+        const sourceOutPath = this.getProjectPathTranslator(this.data.tsConfigPath).getOutputPath(sourceFile.fileName);
+        const rbxPath = this.rojoResolver.getRbxPathFromFilePath(sourceOutPath);
+        this.isInReplicatedFirst = rbxPath !== undefined && rbxPath[0] === "ReplicatedFirst";
+    }
+    pushTryUsesStack() {
+        const tryUses = {
+            usesReturn: false,
+            usesBreak: false,
+            usesContinue: false,
+        };
+        this.tryUsesStack.push(tryUses);
+        return tryUses;
+    }
+    markTryUses(property) {
+        if (this.tryUsesStack.length !== 0) {
+            this.tryUsesStack[this.tryUsesStack.length - 1][property] = true;
+        }
+    }
+    popTryUsesStack() {
+        this.tryUsesStack.pop();
+    }
+    prereq(statement) {
+        luau_ast_1.default.list.push(this.prereqStatementsStack[this.prereqStatementsStack.length - 1], statement);
+    }
+    prereqList(statements) {
+        luau_ast_1.default.list.pushList(this.prereqStatementsStack[this.prereqStatementsStack.length - 1], statements);
+    }
+    pushPrereqStatementsStack() {
+        const prereqStatements = luau_ast_1.default.list.make();
+        this.prereqStatementsStack.push(prereqStatements);
+        return prereqStatements;
+    }
+    popPrereqStatementsStack() {
+        const poppedValue = this.prereqStatementsStack.pop();
+        (0, assert_1.assert)(poppedValue);
+        return poppedValue;
+    }
+    getLeadingComments(node) {
+        var _a;
+        const commentRanges = (_a = typescript_1.default.getLeadingCommentRanges(this.sourceFileText, node.pos)) !== null && _a !== void 0 ? _a : [];
+        return luau_ast_1.default.list.make(...commentRanges.map(commentRange => luau_ast_1.default.comment(this.sourceFileText.substring(commentRange.pos + 2, commentRange.kind === typescript_1.default.SyntaxKind.SingleLineCommentTrivia
+            ? commentRange.end
+            : commentRange.end - 2))));
+    }
+    capturePrereqs(callback) {
+        this.pushPrereqStatementsStack();
+        callback();
+        return this.popPrereqStatementsStack();
+    }
+    capture(callback) {
+        let value;
+        const prereqs = this.capturePrereqs(() => (value = callback()));
+        return [value, prereqs];
+    }
+    noPrereqs(callback) {
+        let expression;
+        const statements = this.capturePrereqs(() => (expression = callback()));
+        (0, assert_1.assert)(luau_ast_1.default.list.isEmpty(statements));
+        return expression;
+    }
+    getType(node) {
+        return (0, getOrSetDefault_1.getOrSetDefault)(this.getTypeCache, node, () => this.typeChecker.getTypeAtLocation((0, traversal_1.skipUpwards)(node)));
+    }
+    TS(node, name) {
+        this.usesRuntimeLib = true;
+        if (this.projectType === constants_1.ProjectType.Game && this.isInReplicatedFirst) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.warnings.runtimeLibUsedInReplicatedFirst(node));
+        }
+        return luau_ast_1.default.property(luau_ast_1.default.globals.TS, name);
+    }
+    createRuntimeLibImport(sourceFile) {
+        if (this.runtimeLibRbxPath) {
+            if (this.projectType === constants_1.ProjectType.Game) {
+                const serviceName = this.runtimeLibRbxPath[0];
+                (0, assert_1.assert)(serviceName);
+                let expression = (0, createGetService_1.createGetService)(serviceName);
+                for (let i = 1; i < this.runtimeLibRbxPath.length; i++) {
+                    expression = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
+                        expression,
+                        name: "WaitForChild",
+                        args: luau_ast_1.default.list.make(luau_ast_1.default.string(this.runtimeLibRbxPath[i])),
+                    });
+                }
+                expression = luau_ast_1.default.call(luau_ast_1.default.globals.require, [expression]);
+                return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                    left: luau_ast_1.default.globals.TS,
+                    right: expression,
+                });
+            }
+            else {
+                const sourceOutPath = this.pathTranslator.getOutputPath(sourceFile.fileName);
+                const rbxPath = this.rojoResolver.getRbxPathFromFilePath(sourceOutPath);
+                if (!rbxPath) {
+                    DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRojoData(sourceFile, path_1.default.relative(this.data.projectPath, sourceOutPath), false));
+                    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                        left: luau_ast_1.default.globals.TS,
+                        right: luau_ast_1.default.none(),
+                    });
+                }
+                return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                    left: luau_ast_1.default.globals.TS,
+                    right: luau_ast_1.default.call(luau_ast_1.default.globals.require, [
+                        (0, expressionChain_1.propertyAccessExpressionChain)(luau_ast_1.default.globals.script, rojo_resolver_1.RojoResolver.relative(rbxPath, this.runtimeLibRbxPath).map(v => v === rojo_resolver_1.RbxPathParent ? constants_1.PARENT_FIELD : v)),
+                    ]),
+                });
+            }
+        }
+        else {
+            return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+                left: luau_ast_1.default.globals.TS,
+                right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: luau_ast_1.default.globals._G,
+                    index: luau_ast_1.default.globals.script,
+                }),
+            });
+        }
+    }
+    pushToVar(expression, name) {
+        const temp = luau_ast_1.default.tempId(name || (expression && (0, valueToIdStr_1.valueToIdStr)(expression)));
+        this.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: temp,
+            right: expression,
+        }));
+        return temp;
+    }
+    pushToVarIfComplex(expression, name) {
+        if (luau_ast_1.default.isSimple(expression)) {
+            return expression;
+        }
+        return this.pushToVar(expression, name);
+    }
+    pushToVarIfNonId(expression, name) {
+        if (luau_ast_1.default.isAnyIdentifier(expression)) {
+            return expression;
+        }
+        return this.pushToVar(expression, name);
+    }
+    getModuleExports(moduleSymbol) {
+        return (0, getOrSetDefault_1.getOrSetDefault)(this.multiTransformState.getModuleExportsCache, moduleSymbol, () => this.typeChecker.getExportsOfModule(moduleSymbol));
+    }
+    getModuleExportsAliasMap(moduleSymbol) {
+        return (0, getOrSetDefault_1.getOrSetDefault)(this.multiTransformState.getModuleExportsAliasMapCache, moduleSymbol, () => {
+            var _a;
+            const aliasMap = new Map();
+            for (const exportSymbol of this.getModuleExports(moduleSymbol)) {
+                const originalSymbol = typescript_1.default.skipAlias(exportSymbol, this.typeChecker);
+                const declaration = (_a = exportSymbol.getDeclarations()) === null || _a === void 0 ? void 0 : _a[0];
+                if (declaration && typescript_1.default.isExportSpecifier(declaration)) {
+                    aliasMap.set(originalSymbol, declaration.name.text);
+                }
+                else {
+                    aliasMap.set(originalSymbol, exportSymbol.name);
+                }
+            }
+            return aliasMap;
+        });
+    }
+    getModuleSymbolFromNode(node) {
+        const moduleAncestor = (0, traversal_1.getModuleAncestor)(node);
+        const exportSymbol = this.typeChecker.getSymbolAtLocation(typescript_1.default.isSourceFile(moduleAncestor) ? moduleAncestor : moduleAncestor.name);
+        (0, assert_1.assert)(exportSymbol);
+        return exportSymbol;
+    }
+    getModuleIdFromSymbol(moduleSymbol) {
+        const moduleId = this.moduleIdBySymbol.get(moduleSymbol);
+        (0, assert_1.assert)(moduleId);
+        return moduleId;
+    }
+    setModuleIdBySymbol(moduleSymbol, moduleId) {
+        this.moduleIdBySymbol.set(moduleSymbol, moduleId);
+    }
+    getModuleIdFromNode(node) {
+        const moduleSymbol = this.getModuleSymbolFromNode(node);
+        return this.getModuleIdFromSymbol(moduleSymbol);
+    }
+    getModuleIdPropertyAccess(idSymbol) {
+        if (idSymbol.valueDeclaration) {
+            const moduleSymbol = this.getModuleSymbolFromNode(idSymbol.valueDeclaration);
+            const alias = this.getModuleExportsAliasMap(moduleSymbol).get(idSymbol);
+            if (alias) {
+                return luau_ast_1.default.property(this.getModuleIdFromSymbol(moduleSymbol), alias);
+            }
+        }
+    }
+    guessVirtualPath(fsPath) {
+        var _a, _b, _c;
+        const reverseSymlinkMap = (_b = (_a = this.program).getSymlinkCache) === null || _b === void 0 ? void 0 : _b.call(_a).getSymlinkedDirectoriesByRealpath();
+        if (!reverseSymlinkMap)
+            return;
+        const original = fsPath;
+        while (true) {
+            const parent = typescript_1.default.ensureTrailingDirectorySeparator(path_1.default.dirname(fsPath));
+            if (fsPath === parent)
+                break;
+            fsPath = parent;
+            const symlink = (_c = reverseSymlinkMap.get(typescript_1.default.toPath(fsPath, this.program.getCurrentDirectory(), getCanonicalFileName_1.getCanonicalFileName))) === null || _c === void 0 ? void 0 : _c[0];
+            if (symlink) {
+                return path_1.default.join(symlink, path_1.default.relative(fsPath, original));
+            }
+        }
+    }
+    setClassElementObjectKey(classElement, identifier) {
+        (0, assert_1.assert)(!this.classElementToObjectKeyMap.has(classElement));
+        this.classElementToObjectKeyMap.set(classElement, identifier);
+    }
+    getClassElementObjectKey(classElement) {
+        return this.classElementToObjectKeyMap.get(classElement);
+    }
+    getPathTranslatorForFile(filePath) {
+        const normalizedFilePath = path_1.default.normalize(filePath);
+        for (const project of this.data.referencedProjects) {
+            const normalizedRootDir = path_1.default.normalize(project.rootDir);
+            const normalizedOutDir = path_1.default.normalize(project.outDir);
+            if (normalizedFilePath.startsWith(normalizedRootDir + path_1.default.sep) ||
+                normalizedFilePath === normalizedRootDir ||
+                normalizedFilePath.startsWith(normalizedOutDir + path_1.default.sep) ||
+                normalizedFilePath === normalizedOutDir) {
+                return this.getProjectPathTranslator(project.tsConfigPath);
+            }
+        }
+        return this.pathTranslator;
+    }
+}
+exports.TransformState = TransformState;
+//# sourceMappingURL=TransformState.js.map

package/out/TSTransformer/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./classes/MacroManager";
+export * from "./classes/MultiTransformState";
+export * from "./classes/TransformState";
+export { transformSourceFile } from "./nodes/transformSourceFile";

package/out/TSTransformer/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSourceFile = void 0;
+__exportStar(require("./classes/MacroManager"), exports);
+__exportStar(require("./classes/MultiTransformState"), exports);
+__exportStar(require("./classes/TransformState"), exports);
+var transformSourceFile_1 = require("./nodes/transformSourceFile");
+Object.defineProperty(exports, "transformSourceFile", { enumerable: true, get: function () { return transformSourceFile_1.transformSourceFile; } });
+//# sourceMappingURL=index.js.map

package/out/TSTransformer/macros/callMacros.d.ts

@@ -0,0 +1,2 @@
+import { CallMacro, MacroList } from "./types";
+export declare const CALL_MACROS: MacroList<CallMacro>;

package/out/TSTransformer/macros/callMacros.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CALL_MACROS = 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 convertToIndexableExpression_1 = require("../util/convertToIndexableExpression");
+const createImportExpression_1 = require("../util/createImportExpression");
+const createTruthinessChecks_1 = require("../util/createTruthinessChecks");
+const PRIMITIVE_LUAU_TYPES = new Set([
+    "nil",
+    "boolean",
+    "string",
+    "number",
+    "table",
+    "userdata",
+    "function",
+    "thread",
+    "vector",
+    "buffer",
+]);
+exports.CALL_MACROS = {
+    assert: (state, node, expression, args) => {
+        args[0] = (0, createTruthinessChecks_1.createTruthinessChecks)(state, args[0], node.arguments[0]);
+        return luau_ast_1.default.call(luau_ast_1.default.globals.assert, args);
+    },
+    typeOf: (state, node, expression, args) => luau_ast_1.default.call(luau_ast_1.default.globals.typeof, args),
+    typeIs: (state, node, expression, args) => {
+        const [value, typeStr] = args;
+        const typeFunc = luau_ast_1.default.isStringLiteral(typeStr) && PRIMITIVE_LUAU_TYPES.has(typeStr.value)
+            ? luau_ast_1.default.globals.type
+            : luau_ast_1.default.globals.typeof;
+        return luau_ast_1.default.binary(luau_ast_1.default.call(typeFunc, [value]), "==", typeStr);
+    },
+    classIs: (state, node, expression, args) => {
+        const [value, typeStr] = args;
+        return luau_ast_1.default.binary(luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(value), "ClassName"), "==", typeStr);
+    },
+    identity: (state, node, expression, args) => args[0],
+    $range: (state, node) => {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRangeMacroOutsideForOf(node.expression));
+        return luau_ast_1.default.none();
+    },
+    $tuple: (state, node) => {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noTupleMacroOutsideReturn(node));
+        return luau_ast_1.default.none();
+    },
+    $getModuleTree: (state, node) => {
+        const parts = (0, createImportExpression_1.getImportParts)(state, node.getSourceFile(), node.arguments[0]);
+        return luau_ast_1.default.array([parts.shift(), luau_ast_1.default.array(parts)]);
+    },
+};
+//# sourceMappingURL=callMacros.js.map

package/out/TSTransformer/macros/constructorMacros.d.ts

@@ -0,0 +1,2 @@
+import { ConstructorMacro, MacroList } from "./types";
+export declare const CONSTRUCTOR_MACROS: MacroList<ConstructorMacro>;

package/out/TSTransformer/macros/constructorMacros.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSTRUCTOR_MACROS = void 0;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../Shared/util/assert");
+const transformExpression_1 = require("../nodes/expressions/transformExpression");
+const ensureTransformOrder_1 = require("../util/ensureTransformOrder");
+const typescript_1 = __importDefault(require("typescript"));
+function wrapWeak(state, node, macro) {
+    return luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [
+        macro(state, node),
+        luau_ast_1.default.map([[luau_ast_1.default.strings.__mode, luau_ast_1.default.strings.k]]),
+    ]);
+}
+const ArrayConstructor = (state, node) => {
+    if (node.arguments && node.arguments.length > 0) {
+        const args = (0, ensureTransformOrder_1.ensureTransformOrder)(state, node.arguments);
+        return luau_ast_1.default.call(luau_ast_1.default.globals.table.create, args);
+    }
+    return luau_ast_1.default.array();
+};
+const SetConstructor = (state, node) => {
+    if (!node.arguments || node.arguments.length === 0) {
+        return luau_ast_1.default.set();
+    }
+    const arg = node.arguments[0];
+    if (typescript_1.default.isArrayLiteralExpression(arg) && !arg.elements.some(typescript_1.default.isSpreadElement)) {
+        return luau_ast_1.default.set((0, ensureTransformOrder_1.ensureTransformOrder)(state, arg.elements));
+    }
+    else {
+        const id = state.pushToVar(luau_ast_1.default.set(), "set");
+        const valueId = luau_ast_1.default.tempId("v");
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+            ids: luau_ast_1.default.list.make(luau_ast_1.default.tempId(), valueId),
+            expression: (0, transformExpression_1.transformExpression)(state, arg),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: id,
+                    index: valueId,
+                }),
+                operator: "=",
+                right: luau_ast_1.default.bool(true),
+            })),
+        }));
+        return id;
+    }
+};
+const MapConstructor = (state, node) => {
+    if (!node.arguments || node.arguments.length === 0) {
+        return luau_ast_1.default.map();
+    }
+    const arg = node.arguments[0];
+    const transformed = (0, transformExpression_1.transformExpression)(state, arg);
+    if (luau_ast_1.default.isArray(transformed) && luau_ast_1.default.list.every(transformed.members, member => luau_ast_1.default.isArray(member))) {
+        const elements = luau_ast_1.default.list.toArray(transformed.members).map(e => {
+            (0, assert_1.assert)(luau_ast_1.default.isArray(e) && luau_ast_1.default.list.isNonEmpty(e.members));
+            return [e.members.head.value, e.members.head.next.value];
+        });
+        return luau_ast_1.default.map(elements);
+    }
+    else {
+        const id = state.pushToVar(luau_ast_1.default.map(), "map");
+        const valueId = luau_ast_1.default.tempId("v");
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+            ids: luau_ast_1.default.list.make(luau_ast_1.default.tempId(), valueId),
+            expression: transformed,
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: id,
+                    index: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                        expression: valueId,
+                        index: luau_ast_1.default.number(1),
+                    }),
+                }),
+                operator: "=",
+                right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: valueId,
+                    index: luau_ast_1.default.number(2),
+                }),
+            })),
+        }));
+        return id;
+    }
+};
+exports.CONSTRUCTOR_MACROS = {
+    ArrayConstructor,
+    SetConstructor,
+    MapConstructor,
+    WeakSetConstructor: (state, node) => wrapWeak(state, node, SetConstructor),
+    WeakMapConstructor: (state, node) => wrapWeak(state, node, MapConstructor),
+    ReadonlyMapConstructor: MapConstructor,
+    ReadonlySetConstructor: SetConstructor,
+};
+//# sourceMappingURL=constructorMacros.js.map

package/out/TSTransformer/macros/identifierMacros.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierMacro, MacroList } from "./types";
+export declare const IDENTIFIER_MACROS: MacroList<IdentifierMacro>;

package/out/TSTransformer/macros/identifierMacros.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDENTIFIER_MACROS = void 0;
+exports.IDENTIFIER_MACROS = {
+    Promise: (state, node) => state.TS(node, "Promise"),
+};
+//# sourceMappingURL=identifierMacros.js.map

package/out/TSTransformer/macros/propertyCallMacros.d.ts

@@ -0,0 +1,4 @@
+import { MacroList, PropertyCallMacro } from "./types";
+export declare const PROPERTY_CALL_MACROS: {
+    [className: string]: MacroList<PropertyCallMacro>;
+};