rbxts-transform-boost 0.1.0 → 1.1.0

package/src/passes/cache.ts

@@ -1,163 +0,0 @@
-import type ts from "typescript";
-import { chainKey, walk, isAssignmentTarget } from "../util";
-
-function isGetServiceCall(ts: typeof import("typescript"), node: ts.Node): node is ts.CallExpression {
-    if (!ts.isCallExpression(node)) return false;
-    const expr = node.expression;
-    if (!ts.isPropertyAccessExpression(expr)) return false;
-    const obj = expr.expression;
-    return ts.isIdentifier(obj) && obj.text === "game" && expr.name.text === "GetService";
-}
-
-function getServiceName(ts: typeof import("typescript"), call: ts.CallExpression): string | undefined {
-    const args = call.arguments;
-    if (args.length !== 1) return undefined;
-    const arg = args[0];
-    if (!ts.isStringLiteral(arg)) return undefined;
-    return arg.text;
-}
-
-export function cachePass(
-    ts: typeof import("typescript"),
-    _program: ts.Program,
-    ctx: ts.TransformationContext,
-    sourceFile: ts.SourceFile,
-): ts.SourceFile {
-    const factory = ctx.factory;
-
-    // --- GetService hoisting ---
-    const services = new Map<string, string>();
-    walk(ts, sourceFile, node => {
-        if (!node || !isGetServiceCall(ts, node)) return;
-        const name = getServiceName(ts, node as ts.CallExpression);
-        if (name && !services.has(name)) services.set(name, `_${name}`);
-    });
-
-    const serviceVisitor = (node: ts.Node): ts.Node => {
-        if (isGetServiceCall(ts, node)) {
-            const name = getServiceName(ts, node as ts.CallExpression);
-            if (name && services.has(name)) return factory.createIdentifier(services.get(name)!);
-        }
-        return ts.visitEachChild(node, serviceVisitor, ctx);
-    };
-
-    let result = ts.visitEachChild(sourceFile, serviceVisitor, ctx) as ts.SourceFile;
-
-    if (services.size > 0) {
-        const hoistDecls = Array.from(services.entries()).map(([name, localName]) =>
-            factory.createVariableStatement(
-                undefined,
-                factory.createVariableDeclarationList(
-                    [factory.createVariableDeclaration(
-                        factory.createIdentifier(localName),
-                        undefined,
-                        undefined,
-                        factory.createCallExpression(
-                            factory.createPropertyAccessExpression(
-                                factory.createIdentifier("game"),
-                                "GetService",
-                            ),
-                            undefined,
-                            [factory.createStringLiteral(name)],
-                        ),
-                    )],
-                    ts.NodeFlags.Const,
-                ),
-            )
-        );
-        result = factory.updateSourceFile(result, [...hoistDecls, ...Array.from(result.statements)]);
-    }
-
-    // --- Property chain hoisting within functions ---
-    result = hoistPropertyChains(ts, result, factory, ctx);
-    return result;
-}
-
-function hoistPropertyChains(
-    ts: typeof import("typescript"),
-    sourceFile: ts.SourceFile,
-    factory: ts.NodeFactory,
-    ctx: ts.TransformationContext,
-): ts.SourceFile {
-    const visitor = (node: ts.Node): ts.Node => {
-        if (
-            ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ||
-            ts.isArrowFunction(node) || ts.isMethodDeclaration(node)
-        ) {
-            return hoistInFunction(ts, node as ts.FunctionLikeDeclaration, factory, ctx);
-        }
-        return ts.visitEachChild(node, visitor, ctx);
-    };
-    return ts.visitEachChild(sourceFile, visitor, ctx) as ts.SourceFile;
-}
-
-function hoistInFunction(
-    ts: typeof import("typescript"),
-    fn: ts.FunctionLikeDeclaration,
-    factory: ts.NodeFactory,
-    ctx: ts.TransformationContext,
-): ts.FunctionLikeDeclaration {
-    if (!fn.body || !ts.isBlock(fn.body)) return fn;
-
-    const counts = new Map<string, number>();
-    walk(ts, fn.body, node => {
-        if (!node || !ts.isPropertyAccessExpression(node)) return;
-        const key = chainKey(ts, node);
-        if (!key || !key.includes(".")) return;
-        if (isAssignmentTarget(ts, node)) return;
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-    });
-
-    const toHoist = new Map<string, string>();
-    let counter = 0;
-
-    const candidates = Array.from(counts.entries())
-        .filter(([, count]) => count >= 2)
-        .sort((a, b) => b[0].length - a[0].length);
-
-    for (const [key] of candidates) {
-        const alreadyCovered = Array.from(toHoist.keys()).some(h => h.startsWith(key + "."));
-        if (alreadyCovered) continue;
-        toHoist.set(key, `_cache${counter++}`);
-    }
-
-    if (toHoist.size === 0) return fn;
-
-    const chainVisitor = (node: ts.Node): ts.Node => {
-        if (ts.isPropertyAccessExpression(node)) {
-            const key = chainKey(ts, node);
-            if (key && toHoist.has(key) && !isAssignmentTarget(ts, node)) {
-                return factory.createIdentifier(toHoist.get(key)!);
-            }
-        }
-        return ts.visitEachChild(node, chainVisitor, ctx);
-    };
-
-    const newBody = ts.visitEachChild(fn.body, chainVisitor, ctx) as ts.Block;
-
-    const hoistStmts = Array.from(toHoist.entries()).map(([key, localName]) => {
-        const parts = key.split(".");
-        let expr: ts.Expression = factory.createIdentifier(parts[0]);
-        for (let i = 1; i < parts.length; i++) {
-            expr = factory.createPropertyAccessExpression(expr, parts[i]);
-        }
-        return factory.createVariableStatement(
-            undefined,
-            factory.createVariableDeclarationList(
-                [factory.createVariableDeclaration(
-                    factory.createIdentifier(localName),
-                    undefined, undefined, expr,
-                )],
-                ts.NodeFlags.Const,
-            ),
-        );
-    });
-
-    const updatedBody = factory.updateBlock(newBody, [...hoistStmts, ...Array.from(newBody.statements)]);
-
-    if (ts.isFunctionDeclaration(fn)) return factory.updateFunctionDeclaration(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.typeParameters, fn.parameters, fn.type, updatedBody);
-    if (ts.isFunctionExpression(fn)) return factory.updateFunctionExpression(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.typeParameters, fn.parameters, fn.type, updatedBody);
-    if (ts.isArrowFunction(fn)) return factory.updateArrowFunction(fn, fn.modifiers, fn.typeParameters, fn.parameters, fn.type, fn.equalsGreaterThanToken, updatedBody);
-    if (ts.isMethodDeclaration(fn)) return factory.updateMethodDeclaration(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.questionToken, fn.typeParameters, fn.parameters, fn.type, updatedBody);
-    return fn;
-}

package/src/passes/loops.ts

@@ -1,80 +0,0 @@
-import type ts from "typescript";
-
-export function loopsPass(
-    ts: typeof import("typescript"),
-    _program: ts.Program,
-    ctx: ts.TransformationContext,
-    sourceFile: ts.SourceFile,
-): ts.SourceFile {
-    const factory = ctx.factory;
-
-    function isArrayLengthExpr(node: ts.Expression): ts.Expression | undefined {
-        // matches: arr.size() or arr.length (if it ever appears)
-        if (ts.isCallExpression(node)) {
-            const expr = node.expression;
-            if (ts.isPropertyAccessExpression(expr) && expr.name.text === "size" && node.arguments.length === 0) {
-                return expr.expression;
-            }
-        }
-        return undefined;
-    }
-
-    function rewriteForLoop(node: ts.ForStatement): ts.Statement {
-        // Match: for (let i = 0; i < arr.size(); i++) { ... }
-        const { initializer, condition, incrementor, statement } = node;
-        if (!initializer || !condition || !incrementor) return node;
-        if (!ts.isVariableDeclarationList(initializer)) return node;
-        const decls = initializer.declarations;
-        if (decls.length !== 1) return node;
-        const decl = decls[0];
-        if (!ts.isIdentifier(decl.name)) return node;
-        if (!decl.initializer || !ts.isNumericLiteral(decl.initializer) || decl.initializer.text !== "0") return node;
-        if (!ts.isBinaryExpression(condition)) return node;
-        if (condition.operatorToken.kind !== ts.SyntaxKind.LessThanToken) return node;
-
-        const arr = isArrayLengthExpr(condition.right);
-        if (!arr) return node;
-
-        const loopVar = decl.name.text;
-        const arrName = ts.isIdentifier(arr) ? arr.text : undefined;
-        if (!arrName) return node;
-
-        const lenName = `_len_${arrName}`;
-        const lenDecl = factory.createVariableStatement(
-            undefined,
-            factory.createVariableDeclarationList(
-                [factory.createVariableDeclaration(
-                    factory.createIdentifier(lenName),
-                    undefined,
-                    factory.createTypeReferenceNode("number"),
-                    factory.createCallExpression(
-                        factory.createPropertyAccessExpression(arr, "size"),
-                        undefined, [],
-                    ),
-                )],
-                ts.NodeFlags.Const,
-            ),
-        );
-
-        const newCondition = factory.updateBinaryExpression(
-            condition,
-            condition.left,
-            condition.operatorToken,
-            factory.createIdentifier(lenName),
-        );
-        const newFor = factory.updateForStatement(
-            node, initializer, newCondition, incrementor, statement,
-        );
-
-        return factory.createBlock([lenDecl, newFor], true) as unknown as ts.Statement;
-    }
-
-    const visitor = (node: ts.Node): ts.Node => {
-        if (ts.isForStatement(node)) {
-            return rewriteForLoop(node);
-        }
-        return ts.visitEachChild(node, visitor, ctx);
-    };
-
-    return ts.visitEachChild(sourceFile, visitor, ctx) as ts.SourceFile;
-}

package/src/passes/native.ts

@@ -1,19 +0,0 @@
-import type ts from "typescript";
-import { hasOptimizeDirective } from "../util";
-
-export function nativePass(
-    ts: typeof import("typescript"),
-    ctx: ts.TransformationContext,
-    sourceFile: ts.SourceFile,
-): ts.SourceFile {
-    if (hasOptimizeDirective(sourceFile)) return sourceFile;
-
-    const factory = ctx.factory;
-    const optimize = ts.addSyntheticLeadingComment(
-        factory.createNotEmittedStatement(sourceFile),
-        ts.SyntaxKind.SingleLineCommentTrivia,
-        "!optimize 2",
-        true,
-    );
-    return factory.updateSourceFile(sourceFile, [optimize, ...Array.from(sourceFile.statements)]);
-}

package/src/util.ts

@@ -1,33 +0,0 @@
-import type ts from "typescript";
-
-export function hasOptimizeDirective(sourceFile: ts.SourceFile): boolean {
-    return /^--!optimize\b/m.test(sourceFile.text) || /^\/\/!optimize\b/m.test(sourceFile.text);
-}
-
-export function chainKey(ts: typeof import("typescript"), node: ts.Expression): string | undefined {
-    if (ts.isIdentifier(node)) return node.text;
-    if (ts.isPropertyAccessExpression(node)) {
-        const left = chainKey(ts, node.expression);
-        if (left === undefined) return undefined;
-        return `${left}.${node.name.text}`;
-    }
-    return undefined;
-}
-
-export function walk(ts: typeof import("typescript"), node: ts.Node, visitor: (n: ts.Node) => void): void {
-    if (!node) return;
-    visitor(node);
-    ts.forEachChild(node, child => { if (child) walk(ts, child, visitor); });
-}
-
-export function isAssignmentTarget(ts: typeof import("typescript"), node: ts.Node): boolean {
-    const parent = node.parent;
-    if (!parent) return false;
-    if (ts.isBinaryExpression(parent)) {
-        return parent.left === node &&
-            parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
-    }
-    if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) return true;
-    return false;
-}
-

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "module": "commonjs",
-        "moduleResolution": "node",
-        "strict": true,
-        "declaration": true,
-        "outDir": "dist",
-        "rootDir": "src",
-        "esModuleInterop": true,
-        "paths": { "typescript": ["./test/node_modules/typescript"] },
-        "skipLibCheck": true,
-        "types": ["node"]
-    },
-    "include": ["src"]
-}