rbxts-transform-boost 0.1.0

package/dist/util.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOptimizeDirective = hasOptimizeDirective;
+exports.chainKey = chainKey;
+exports.walk = walk;
+exports.isAssignmentTarget = isAssignmentTarget;
+function hasOptimizeDirective(sourceFile) {
+    return /^--!optimize\b/m.test(sourceFile.text) || /^\/\/!optimize\b/m.test(sourceFile.text);
+}
+function chainKey(ts, node) {
+    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;
+}
+function walk(ts, node, visitor) {
+    if (!node)
+        return;
+    visitor(node);
+    ts.forEachChild(node, child => { if (child)
+        walk(ts, child, visitor); });
+}
+function isAssignmentTarget(ts, node) {
+    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/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "rbxts-transform-boost",
+    "version": "0.1.0",
+    "description": "roblox-ts transformer: automatic --!native, GetService hoisting, property chain caching, loop bounds hoisting, and Luau type annotation injection",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "bench:build": "npm run build && cd bench && ~/.rokit/bin/rotor build",
+        "bench:build:baseline": "cd bench && ~/.rokit/bin/rotor build -p tsconfig.notransform.json -i out/include",
+        "bench:dev": "cd bench && ~/.rokit/bin/rotor dev",
+        "bench:rbxlx": "npm run bench:build && npm run bench:build:baseline && cd bench && ~/.rokit/bin/rojo build benchmark.project.json -o benchmark.rbxlx"
+    },
+    "keywords": [
+        "roblox-ts",
+        "rbxts",
+        "transformer",
+        "luau",
+        "native",
+        "performance"
+    ],
+    "peerDependencies": {
+        "typescript": ">=5.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^26.0.0"
+    }
+}

package/rokit.toml

@@ -0,0 +1,3 @@
+[tools]
+rojo = "rojo-rbx/rojo@7.6.1"
+rotor = "uproot/rotor@2.2.0"

package/scripts/postprocess.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Replaces "-- !fn-native\n" markers (emitted by rbxts-transform-perf's native pass)
+// with bare "@native\n" Luau attributes in compiled output files.
+// Run after `rotor build` to make per-function @native actually take effect.
+
+const fs = require("fs");
+const path = require("path");
+
+const MARKER = "--!fn-native\n";
+const ATTRIBUTE = "@native\n";
+
+function processDir(dir) {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            processDir(full);
+        } else if (entry.name.endsWith(".luau") || entry.name.endsWith(".lua")) {
+            const original = fs.readFileSync(full, "utf8");
+            if (!original.includes(MARKER)) continue;
+            const patched = original.replaceAll(MARKER, ATTRIBUTE);
+            fs.writeFileSync(full, patched, "utf8");
+            console.log(`@native patched: ${full}`);
+        }
+    }
+}
+
+const outDir = process.argv[2] ?? path.join(__dirname, "..", "test", "out");
+processDir(outDir);

package/src/config.ts

@@ -0,0 +1,10 @@
+export interface PluginConfig {
+    // Prepend --!optimize 2 to every file that doesn't already have it.
+    // Default: true
+    optimize?: boolean;
+
+    // Hoist repeated game.GetService() calls to module-level locals,
+    // and hoist repeated property access chains within functions to locals.
+    // Default: true
+    hoist?: boolean;
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+import type ts from "typescript";
+import type { PluginConfig } from "./config";
+import { nativePass } from "./passes/native";
+import { cachePass } from "./passes/cache";
+import { loopsPass } from "./passes/loops";
+import { annotatePass } from "./passes/annotate";
+
+export type { PluginConfig };
+
+export default function(
+    program: ts.Program,
+    config: PluginConfig = {},
+    { ts }: { ts: typeof import("typescript") },
+): ts.TransformerFactory<ts.SourceFile> {
+    const { optimize = true, hoist = true } = config;
+
+    return (ctx: ts.TransformationContext) => (sourceFile: ts.SourceFile): ts.SourceFile => {
+        annotatePass(ts, program, sourceFile);
+        let result = sourceFile;
+        if (hoist) result = cachePass(ts, program, ctx, result);
+        result = loopsPass(ts, program, ctx, result);
+        if (optimize) result = nativePass(ts, ctx, result);
+        return result;
+    };
+}

package/src/passes/annotate.ts

@@ -0,0 +1,207 @@
+import type ts from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+
+// Luau type names for TypeScript type strings rotor knows about
+const LUAU_TYPE: Record<string, string> = {
+    number: "number",
+    string: "string",
+    boolean: "boolean",
+    Vector3: "Vector3",
+    Vector2: "Vector2",
+    Vector2int16: "Vector2int16",
+    Vector3int16: "Vector3int16",
+    CFrame: "CFrame",
+    UDim: "UDim",
+    UDim2: "UDim2",
+    Color3: "Color3",
+    BrickColor: "BrickColor",
+    TweenInfo: "TweenInfo",
+    NumberRange: "NumberRange",
+    NumberSequence: "NumberSequence",
+    ColorSequence: "ColorSequence",
+    Rect: "Rect",
+    Region3: "Region3",
+    Ray: "Ray",
+    buffer: "buffer",
+    // Roblox service types
+    Instance: "Instance",
+    BasePart: "BasePart",
+    Part: "Part",
+    Model: "Model",
+    Player: "Player",
+    Camera: "Camera",
+    Workspace: "Workspace",
+    RunService: "RunService",
+    Players: "Players",
+    // Luau numeric arrays — kept as {number} in Luau
+};
+
+type FnAnnotation = {
+    params: Array<string | null>; // null = unknown/skip
+};
+
+// Global sidecar: outLuauPath → list of function annotations for that file
+const sidecar = new Map<string, Map<string, FnAnnotation>>();
+let hooked = false;
+
+function luauTypeForTsType(
+    ts: typeof import("typescript"),
+    checker: ts.TypeChecker,
+    node: ts.ParameterDeclaration,
+): string | null {
+    if (node.type) {
+        const mapped = mapTypeNode(ts, node.type);
+        if (mapped) return mapped;
+    }
+    const type = checker.getTypeAtLocation(node);
+    const name = checker.typeToString(type);
+    return LUAU_TYPE[name] ?? null;
+}
+
+function mapTypeNode(ts: typeof import("typescript"), typeNode: ts.TypeNode): string | null {
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const name = ts.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : null;
+        if (!name) return null;
+        if (LUAU_TYPE[name]) return LUAU_TYPE[name];
+        // Array<T> → {T}
+        if ((name === "Array" || name === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
+            const inner = mapTypeNode(ts, typeNode.typeArguments[0]);
+            return inner ? `{${inner}}` : "{any}";
+        }
+        return null;
+    }
+    if (ts.isArrayTypeNode(typeNode)) {
+        const inner = mapTypeNode(ts, typeNode.elementType);
+        return inner ? `{${inner}}` : "{any}";
+    }
+    const kw: Partial<Record<number, string>> = {
+        [ts.SyntaxKind.NumberKeyword]: "number",
+        [ts.SyntaxKind.StringKeyword]: "string",
+        [ts.SyntaxKind.BooleanKeyword]: "boolean",
+    };
+    if (typeNode.kind in kw) return kw[typeNode.kind]!;
+    return null;
+}
+
+function outPathForSource(
+    sourceFile: ts.SourceFile,
+    program: ts.Program,
+): string | null {
+    const options = program.getCompilerOptions();
+    const outDir = options.outDir;
+    if (!outDir) return null;
+
+    // Compute rootDir: explicit option or the common root of all source files
+    const rootDir = options.rootDir
+        ?? commonRoot(program.getRootFileNames());
+    if (!rootDir) return null;
+
+    const rel = path.relative(rootDir, sourceFile.fileName);
+    if (rel.startsWith("..")) return null;
+
+    // Change .ts / .tsx extension to .luau
+    const luauRel = rel.replace(/\.tsx?$/, ".luau");
+    return path.join(outDir, luauRel);
+}
+
+function commonRoot(files: readonly string[]): string | undefined {
+    if (files.length === 0) return undefined;
+    const parts = files[0].split(path.sep);
+    let root = parts.slice(0, parts.length - 1);
+    for (const f of files.slice(1)) {
+        const fp = f.split(path.sep);
+        let i = 0;
+        while (i < root.length && i < fp.length - 1 && root[i] === fp[i]) i++;
+        root = root.slice(0, i);
+    }
+    return root.join(path.sep) || undefined;
+}
+
+function collectAnnotations(
+    ts: typeof import("typescript"),
+    checker: ts.TypeChecker,
+    sourceFile: ts.SourceFile,
+    outPath: string,
+): void {
+    const fileMap = sidecar.get(outPath) ?? new Map<string, FnAnnotation>();
+    sidecar.set(outPath, fileMap);
+
+    function visit(node: ts.Node): void {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const fnName = node.name.text;
+            const params = node.parameters.map(p => luauTypeForTsType(ts, checker, p));
+            if (params.some(p => p !== null)) {
+                fileMap.set(fnName, { params });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+}
+
+function injectAnnotations(luauPath: string, fileMap: Map<string, FnAnnotation>): void {
+    if (!fs.existsSync(luauPath)) return;
+    let src = fs.readFileSync(luauPath, "utf8");
+    let changed = false;
+
+    for (const [fnName, ann] of fileMap) {
+        if (ann.params.every(p => p === null)) continue;
+
+        // Match: local function fnName(a, b, c)
+        // Captures the param list so we can replace individual names
+        const re = new RegExp(
+            `(local function ${escapeRegex(fnName)}\\()([^)]*)(\\.\\.\\.\\))?\\)`,
+        );
+        src = src.replace(re, (_match: string, open: string, rawParams: string, vararg: string | undefined) => {
+            const names = rawParams.split(",").map((s: string) => s.trim()).filter(Boolean);
+            const annotated = names.map((name: string, i: number) => {
+                // strip any existing annotation
+                const bare = name.split(":")[0].trim();
+                const typ = ann.params[i];
+                return typ ? `${bare}: ${typ}` : bare;
+            });
+            if (vararg) annotated.push("...");
+            changed = true;
+            return `${open}${annotated.join(", ")})`;
+        });
+    }
+
+    if (changed) fs.writeFileSync(luauPath, src, "utf8");
+}
+
+function escapeRegex(s: string): string {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function installWatcher(outDir: string): void {
+    if (hooked) return;
+    hooked = true;
+    const seen = new Set<string>();
+    const watcher = fs.watch(outDir, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith(".luau")) return;
+        const full = path.join(outDir, filename);
+        if (seen.has(full)) return;
+        const fileMap = sidecar.get(full);
+        if (!fileMap) return;
+        seen.add(full);
+        if (fileMap.size > 0) {
+            try { injectAnnotations(full, fileMap); } catch { /* ignore */ }
+        }
+    });
+    watcher.unref();
+}
+
+export function annotatePass(
+    ts: typeof import("typescript"),
+    program: ts.Program,
+    sourceFile: ts.SourceFile,
+): void {
+    const outPath = outPathForSource(sourceFile, program);
+    if (!outPath) return;
+
+    const checker = program.getTypeChecker();
+    collectAnnotations(ts, checker, sourceFile, outPath);
+    const outDir = program.getCompilerOptions().outDir!;
+    installWatcher(outDir);
+}

package/src/passes/cache.ts

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,16 @@
+{
+    "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"]
+}