@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Shared/util/realPathExistsSync.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realPathExistsSync = realPathExistsSync;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function realPathExistsSync(fsPath) {
+    if (fs_extra_1.default.pathExistsSync(fsPath)) {
+        return fs_extra_1.default.realpathSync(fsPath);
+    }
+}
+//# sourceMappingURL=realPathExistsSync.js.map

package/out/Shared/warn.d.ts

@@ -0,0 +1 @@
+export declare function warn(message: string): void;

package/out/Shared/warn.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+const kleur_1 = __importDefault(require("kleur"));
+const LogService_1 = require("./classes/LogService");
+function warn(message) {
+    LogService_1.LogService.writeLine(`${kleur_1.default.yellow("Compiler Warning:")} ${message}`);
+}
+//# sourceMappingURL=warn.js.map

package/out/TSTransformer/classes/DiagnosticService.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+export declare class DiagnosticService {
+    private static diagnostics;
+    private static singleDiagnostics;
+    static addSingleDiagnostic(diagnostic: ts.Diagnostic): void;
+    static addDiagnostic(diagnostic: ts.Diagnostic): void;
+    static addDiagnostics(diagnostics: ReadonlyArray<ts.Diagnostic>): void;
+    static addDiagnosticWithCache<T>(cacheBy: T, diagnostic: ts.Diagnostic, cache: Set<T>): void;
+    static flush(): ts.Diagnostic[];
+    static hasErrors(): boolean;
+}

package/out/TSTransformer/classes/DiagnosticService.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticService = void 0;
+const hasErrors_1 = require("../../Shared/util/hasErrors");
+class DiagnosticService {
+    static addSingleDiagnostic(diagnostic) {
+        if (!this.singleDiagnostics.has(diagnostic.code)) {
+            this.singleDiagnostics.add(diagnostic.code);
+            this.addDiagnostic(diagnostic);
+        }
+    }
+    static addDiagnostic(diagnostic) {
+        this.diagnostics.push(diagnostic);
+    }
+    static addDiagnostics(diagnostics) {
+        this.diagnostics.push(...diagnostics);
+    }
+    static addDiagnosticWithCache(cacheBy, diagnostic, cache) {
+        if (!cache.has(cacheBy)) {
+            cache.add(cacheBy);
+            this.addDiagnostic(diagnostic);
+        }
+    }
+    static flush() {
+        const current = this.diagnostics;
+        this.diagnostics = [];
+        this.singleDiagnostics.clear();
+        return current;
+    }
+    static hasErrors() {
+        return (0, hasErrors_1.hasErrors)(this.diagnostics);
+    }
+}
+exports.DiagnosticService = DiagnosticService;
+DiagnosticService.diagnostics = new Array();
+DiagnosticService.singleDiagnostics = new Set();
+//# sourceMappingURL=DiagnosticService.js.map

package/out/TSTransformer/classes/MacroManager.d.ts

@@ -0,0 +1,46 @@
+import { CallMacro, ConstructorMacro, IdentifierMacro, PropertyCallMacro } from "../macros/types";
+import ts from "typescript";
+export declare const SYMBOL_NAMES: {
+    readonly globalThis: "globalThis";
+    readonly ArrayConstructor: "ArrayConstructor";
+    readonly SetConstructor: "SetConstructor";
+    readonly MapConstructor: "MapConstructor";
+    readonly WeakSetConstructor: "WeakSetConstructor";
+    readonly WeakMapConstructor: "WeakMapConstructor";
+    readonly ReadonlyMapConstructor: "ReadonlyMapConstructor";
+    readonly ReadonlySetConstructor: "ReadonlySetConstructor";
+    readonly Array: "Array";
+    readonly Generator: "Generator";
+    readonly IterableFunction: "IterableFunction";
+    readonly LuaTuple: "LuaTuple";
+    readonly Map: "Map";
+    readonly Object: "Object";
+    readonly ReadonlyArray: "ReadonlyArray";
+    readonly ReadonlyMap: "ReadonlyMap";
+    readonly ReadonlySet: "ReadonlySet";
+    readonly ReadVoxelsArray: "ReadVoxelsArray";
+    readonly Set: "Set";
+    readonly SharedTable: "SharedTable";
+    readonly String: "String";
+    readonly TemplateStringsArray: "TemplateStringsArray";
+    readonly WeakMap: "WeakMap";
+    readonly WeakSet: "WeakSet";
+    readonly Iterable: "Iterable";
+    readonly $range: "$range";
+    readonly $tuple: "$tuple";
+};
+export declare const NOMINAL_LUA_TUPLE_NAME = "_nominal_LuaTuple";
+export declare class MacroManager {
+    private symbols;
+    private identifierMacros;
+    private callMacros;
+    private constructorMacros;
+    private propertyCallMacros;
+    constructor(typeChecker: ts.TypeChecker);
+    getSymbolOrThrow(name: string): ts.Symbol;
+    isMacroOnlyClass(symbol: ts.Symbol): boolean;
+    getIdentifierMacro(symbol: ts.Symbol): IdentifierMacro | undefined;
+    getCallMacro(symbol: ts.Symbol): CallMacro | undefined;
+    getConstructorMacro(symbol: ts.Symbol): ConstructorMacro | undefined;
+    getPropertyCallMacro(symbol: ts.Symbol): PropertyCallMacro | undefined;
+}

package/out/TSTransformer/classes/MacroManager.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacroManager = exports.NOMINAL_LUA_TUPLE_NAME = exports.SYMBOL_NAMES = void 0;
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const assert_1 = require("../../Shared/util/assert");
+const callMacros_1 = require("../macros/callMacros");
+const constructorMacros_1 = require("../macros/constructorMacros");
+const identifierMacros_1 = require("../macros/identifierMacros");
+const propertyCallMacros_1 = require("../macros/propertyCallMacros");
+const traversal_1 = require("../util/traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function getType(typeChecker, node) {
+    return typeChecker.getTypeAtLocation((0, traversal_1.skipUpwards)(node));
+}
+const TYPES_NOTICE = "\nYou may need to update your @rbxts/compiler-types!";
+exports.SYMBOL_NAMES = {
+    globalThis: "globalThis",
+    ArrayConstructor: "ArrayConstructor",
+    SetConstructor: "SetConstructor",
+    MapConstructor: "MapConstructor",
+    WeakSetConstructor: "WeakSetConstructor",
+    WeakMapConstructor: "WeakMapConstructor",
+    ReadonlyMapConstructor: "ReadonlyMapConstructor",
+    ReadonlySetConstructor: "ReadonlySetConstructor",
+    Array: "Array",
+    Generator: "Generator",
+    IterableFunction: "IterableFunction",
+    LuaTuple: "LuaTuple",
+    Map: "Map",
+    Object: "Object",
+    ReadonlyArray: "ReadonlyArray",
+    ReadonlyMap: "ReadonlyMap",
+    ReadonlySet: "ReadonlySet",
+    ReadVoxelsArray: "ReadVoxelsArray",
+    Set: "Set",
+    SharedTable: "SharedTable",
+    String: "String",
+    TemplateStringsArray: "TemplateStringsArray",
+    WeakMap: "WeakMap",
+    WeakSet: "WeakSet",
+    Iterable: "Iterable",
+    $range: "$range",
+    $tuple: "$tuple",
+};
+exports.NOMINAL_LUA_TUPLE_NAME = "_nominal_LuaTuple";
+const MACRO_ONLY_CLASSES = new Set([
+    exports.SYMBOL_NAMES.ReadonlyArray,
+    exports.SYMBOL_NAMES.Array,
+    exports.SYMBOL_NAMES.ReadonlyMap,
+    exports.SYMBOL_NAMES.WeakMap,
+    exports.SYMBOL_NAMES.Map,
+    exports.SYMBOL_NAMES.ReadonlySet,
+    exports.SYMBOL_NAMES.WeakSet,
+    exports.SYMBOL_NAMES.Set,
+    exports.SYMBOL_NAMES.String,
+]);
+function getFirstDeclarationOrThrow(symbol, check) {
+    var _a;
+    for (const declaration of (_a = symbol.declarations) !== null && _a !== void 0 ? _a : []) {
+        if (check(declaration)) {
+            return declaration;
+        }
+    }
+    throw new ProjectError_1.ProjectError("");
+}
+function getGlobalSymbolByNameOrThrow(typeChecker, name, meaning) {
+    const symbol = typeChecker.resolveName(name, undefined, meaning, false);
+    if (symbol) {
+        return symbol;
+    }
+    throw new ProjectError_1.ProjectError(`MacroManager could not find symbol for ${name}` + TYPES_NOTICE);
+}
+function getConstructorSymbol(node) {
+    for (const member of node.members) {
+        if (typescript_1.default.isConstructSignatureDeclaration(member)) {
+            (0, assert_1.assert)(member.symbol);
+            return member.symbol;
+        }
+    }
+    throw new ProjectError_1.ProjectError(`MacroManager could not find constructor for ${node.name.text}` + TYPES_NOTICE);
+}
+class MacroManager {
+    constructor(typeChecker) {
+        var _a, _b, _c;
+        this.symbols = new Map();
+        this.identifierMacros = new Map();
+        this.callMacros = new Map();
+        this.constructorMacros = new Map();
+        this.propertyCallMacros = new Map();
+        for (const [name, macro] of Object.entries(identifierMacros_1.IDENTIFIER_MACROS)) {
+            const symbol = getGlobalSymbolByNameOrThrow(typeChecker, name, typescript_1.default.SymbolFlags.Variable);
+            this.identifierMacros.set(symbol, macro);
+        }
+        for (const [name, macro] of Object.entries(callMacros_1.CALL_MACROS)) {
+            const symbol = getGlobalSymbolByNameOrThrow(typeChecker, name, typescript_1.default.SymbolFlags.Function);
+            this.callMacros.set(symbol, macro);
+        }
+        for (const [className, macro] of Object.entries(constructorMacros_1.CONSTRUCTOR_MACROS)) {
+            const symbol = getGlobalSymbolByNameOrThrow(typeChecker, className, typescript_1.default.SymbolFlags.Interface);
+            const interfaceDec = getFirstDeclarationOrThrow(symbol, typescript_1.default.isInterfaceDeclaration);
+            const constructSymbol = getConstructorSymbol(interfaceDec);
+            this.constructorMacros.set(constructSymbol, macro);
+        }
+        for (const [className, methods] of Object.entries(propertyCallMacros_1.PROPERTY_CALL_MACROS)) {
+            const symbol = getGlobalSymbolByNameOrThrow(typeChecker, className, typescript_1.default.SymbolFlags.Interface);
+            const methodMap = new Map();
+            for (const declaration of (_a = symbol.declarations) !== null && _a !== void 0 ? _a : []) {
+                if (typescript_1.default.isInterfaceDeclaration(declaration)) {
+                    for (const member of declaration.members) {
+                        if (typescript_1.default.isMethodSignature(member) && typescript_1.default.isIdentifier(member.name)) {
+                            const symbol = getType(typeChecker, member).symbol;
+                            (0, assert_1.assert)(symbol);
+                            methodMap.set(member.name.text, symbol);
+                        }
+                    }
+                }
+            }
+            for (const [methodName, macro] of Object.entries(methods)) {
+                const methodSymbol = methodMap.get(methodName);
+                if (!methodSymbol) {
+                    throw new ProjectError_1.ProjectError(`MacroManager could not find method for ${className}.${methodName}` + TYPES_NOTICE);
+                }
+                this.propertyCallMacros.set(methodSymbol, macro);
+            }
+        }
+        for (const symbolName of Object.values(exports.SYMBOL_NAMES)) {
+            const symbol = typeChecker.resolveName(symbolName, undefined, typescript_1.default.SymbolFlags.All, false);
+            if (symbol) {
+                this.symbols.set(symbolName, symbol);
+            }
+            else {
+                throw new ProjectError_1.ProjectError(`MacroManager could not find symbol for ${symbolName}` + TYPES_NOTICE);
+            }
+        }
+        const luaTupleTypeDec = (_c = (_b = this.symbols
+            .get(exports.SYMBOL_NAMES.LuaTuple)) === null || _b === void 0 ? void 0 : _b.declarations) === null || _c === void 0 ? void 0 : _c.find(v => typescript_1.default.isTypeAliasDeclaration(v));
+        if (luaTupleTypeDec) {
+            const nominalLuaTupleSymbol = typeChecker
+                .getTypeAtLocation(luaTupleTypeDec)
+                .getProperty(exports.NOMINAL_LUA_TUPLE_NAME);
+            if (nominalLuaTupleSymbol) {
+                this.symbols.set(exports.NOMINAL_LUA_TUPLE_NAME, nominalLuaTupleSymbol);
+            }
+        }
+    }
+    getSymbolOrThrow(name) {
+        const symbol = this.symbols.get(name);
+        (0, assert_1.assert)(symbol);
+        return symbol;
+    }
+    isMacroOnlyClass(symbol) {
+        return this.symbols.get(symbol.name) === symbol && MACRO_ONLY_CLASSES.has(symbol.name);
+    }
+    getIdentifierMacro(symbol) {
+        return this.identifierMacros.get(symbol);
+    }
+    getCallMacro(symbol) {
+        return this.callMacros.get(symbol);
+    }
+    getConstructorMacro(symbol) {
+        return this.constructorMacros.get(symbol);
+    }
+    getPropertyCallMacro(symbol) {
+        const macro = this.propertyCallMacros.get(symbol);
+        if (!macro &&
+            symbol.parent &&
+            this.symbols.get(symbol.parent.name) === symbol.parent &&
+            this.isMacroOnlyClass(symbol.parent)) {
+            (0, assert_1.assert)(false, `Macro ${symbol.parent.name}.${symbol.name}() is not implemented!`);
+        }
+        return macro;
+    }
+}
+exports.MacroManager = MacroManager;
+//# sourceMappingURL=MacroManager.js.map

package/out/TSTransformer/classes/MultiTransformState.d.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+export declare class MultiTransformState {
+    readonly isMethodCache: Map<ts.Symbol, boolean>;
+    readonly isDefinedAsLetCache: Map<ts.Symbol, boolean>;
+    readonly isReportedByNoAnyCache: Set<ts.Symbol>;
+    readonly isReportedByMultipleDefinitionsCache: Set<ts.Symbol>;
+    readonly getModuleExportsCache: Map<ts.Symbol, ts.Symbol[]>;
+    readonly getModuleExportsAliasMapCache: Map<ts.Symbol, Map<ts.Symbol, string>>;
+}

package/out/TSTransformer/classes/MultiTransformState.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTransformState = void 0;
+class MultiTransformState {
+    constructor() {
+        this.isMethodCache = new Map();
+        this.isDefinedAsLetCache = new Map();
+        this.isReportedByNoAnyCache = new Set();
+        this.isReportedByMultipleDefinitionsCache = new Set();
+        this.getModuleExportsCache = new Map();
+        this.getModuleExportsAliasMapCache = new Map();
+    }
+}
+exports.MultiTransformState = MultiTransformState;
+//# sourceMappingURL=MultiTransformState.js.map

package/out/TSTransformer/classes/TransformState.d.ts

@@ -0,0 +1,73 @@
+import luau from "@roblox-ts/luau-ast";
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { RbxPath, RojoResolver } from "@roblox-ts/rojo-resolver";
+import { ProjectType } from "../../Shared/constants";
+import { GetProjectPathTranslator, ProjectData } from "../../Shared/types";
+import { MultiTransformState } from "..";
+import { TransformServices, TryUses } from "../types";
+import ts from "typescript";
+export declare class TransformState {
+    readonly program: ts.Program;
+    readonly data: ProjectData;
+    readonly services: TransformServices;
+    readonly pathTranslator: PathTranslator;
+    readonly multiTransformState: MultiTransformState;
+    readonly compilerOptions: ts.CompilerOptions;
+    readonly rojoResolver: RojoResolver;
+    readonly pkgRojoResolvers: Array<RojoResolver>;
+    readonly nodeModulesPathMapping: Map<string, string>;
+    readonly runtimeLibRbxPath: RbxPath | undefined;
+    readonly typeChecker: ts.TypeChecker;
+    readonly projectType: ProjectType;
+    readonly getProjectPathTranslator: GetProjectPathTranslator;
+    private readonly sourceFileText;
+    hasExportEquals: boolean;
+    hasExportFrom: boolean;
+    classIdentifierMap: Map<ts.ClassLikeDeclaration, luau.AnyIdentifier>;
+    debugRender(node: luau.Node): string;
+    debugRenderList(list: luau.List<luau.Statement>): string;
+    readonly resolver: ts.EmitResolver;
+    private isInReplicatedFirst;
+    constructor(program: ts.Program, data: ProjectData, services: TransformServices, pathTranslator: PathTranslator, multiTransformState: MultiTransformState, compilerOptions: ts.CompilerOptions, rojoResolver: RojoResolver, pkgRojoResolvers: Array<RojoResolver>, nodeModulesPathMapping: Map<string, string>, runtimeLibRbxPath: RbxPath | undefined, typeChecker: ts.TypeChecker, projectType: ProjectType, getProjectPathTranslator: GetProjectPathTranslator, sourceFile: ts.SourceFile);
+    readonly tryUsesStack: TryUses[];
+    pushTryUsesStack(): {
+        usesReturn: boolean;
+        usesBreak: boolean;
+        usesContinue: boolean;
+    };
+    markTryUses(property: keyof TryUses): void;
+    popTryUsesStack(): void;
+    readonly prereqStatementsStack: luau.List<luau.Statement<luau.SyntaxKind>>[];
+    prereq(statement: luau.Statement): void;
+    prereqList(statements: luau.List<luau.Statement>): void;
+    pushPrereqStatementsStack(): luau.List<luau.Statement<luau.SyntaxKind>>;
+    popPrereqStatementsStack(): luau.List<luau.Statement<luau.SyntaxKind>>;
+    getLeadingComments(node: ts.Node): luau.List<luau.Comment>;
+    capturePrereqs(callback: () => void): luau.List<luau.Statement<luau.SyntaxKind>>;
+    capture<T>(callback: () => T): [value: T, prereqs: luau.List<luau.Statement>];
+    noPrereqs(callback: () => luau.Expression): luau.Expression<luau.SyntaxKind>;
+    readonly hoistsByStatement: Map<ts.Statement | ts.CaseClause, ts.Identifier[]>;
+    readonly isHoisted: Map<ts.Symbol, boolean>;
+    private getTypeCache;
+    getType(node: ts.Node): ts.Type;
+    usesRuntimeLib: boolean;
+    TS(node: ts.Node, name: string): luau.PropertyAccessExpression;
+    createRuntimeLibImport(sourceFile: ts.SourceFile): luau.VariableDeclaration;
+    pushToVar(expression: luau.Expression | undefined, name?: string): luau.TemporaryIdentifier;
+    pushToVarIfComplex<T extends luau.Expression>(expression: T, name?: string): Extract<T, luau.SimpleTypes> | luau.TemporaryIdentifier;
+    pushToVarIfNonId<T extends luau.Expression>(expression: T, name?: string): luau.AnyIdentifier;
+    getModuleExports(moduleSymbol: ts.Symbol): ts.Symbol[];
+    getModuleExportsAliasMap(moduleSymbol: ts.Symbol): Map<ts.Symbol, string>;
+    private getModuleSymbolFromNode;
+    private readonly moduleIdBySymbol;
+    private getModuleIdFromSymbol;
+    setModuleIdBySymbol(moduleSymbol: ts.Symbol, moduleId: luau.AnyIdentifier): void;
+    getModuleIdFromNode(node: ts.Node): luau.AnyIdentifier;
+    getModuleIdPropertyAccess(idSymbol: ts.Symbol): luau.PropertyAccessExpression | undefined;
+    guessVirtualPath(fsPath: string): string | undefined;
+    symbolToIdMap: Map<ts.Symbol, luau.TemporaryIdentifier>;
+    private classElementToObjectKeyMap;
+    setClassElementObjectKey(classElement: ts.ClassElement, identifier: luau.SimpleTypes): void;
+    getClassElementObjectKey(classElement: ts.ClassElement): luau.SimpleTypes | undefined;
+    getPathTranslatorForFile(filePath: string): PathTranslator;
+}