storm-lua-minify 0.1.2 → 0.2.0

package/dist/resolver.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScopes = resolveScopes;
+function resolveScopes(chunk) {
+    let nextSymbolId = 0;
+    const allSymbols = [];
+    const globals = new Map();
+    const identifierSymbols = new WeakMap();
+    function createScope(kind, parent) {
+        const scope = {
+            kind,
+            parent,
+            children: [],
+            symbols: [],
+            bindings: new Map(),
+            labels: new Map(),
+        };
+        parent?.children.push(scope);
+        return scope;
+    }
+    function declare(scope, node, kind) {
+        const symbol = {
+            id: nextSymbolId++,
+            name: node.name,
+            kind,
+            scope,
+            declaration: node,
+            references: [],
+        };
+        // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
+        scope.symbols.push(symbol);
+        scope.bindings.set(node.name, symbol);
+        allSymbols.push(symbol);
+        identifierSymbols.set(node, symbol);
+        return symbol;
+    }
+    function declareLabel(scope, node) {
+        const symbol = {
+            id: nextSymbolId++,
+            name: node.name,
+            kind: "label",
+            scope,
+            declaration: node,
+            references: [],
+        };
+        scope.symbols.push(symbol);
+        scope.labels.set(node.name, symbol);
+        allSymbols.push(symbol);
+        identifierSymbols.set(node, symbol);
+        return symbol;
+    }
+    function lookupBinding(scope, name) {
+        for (let s = scope; s; s = s.parent) {
+            const found = s.bindings.get(name);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    function lookupLabel(scope, name) {
+        for (let s = scope; s; s = s.parent) {
+            const found = s.labels.get(name);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    function reference(scope, node) {
+        const symbol = lookupBinding(scope, node.name);
+        if (symbol) {
+            symbol.references.push(node);
+            identifierSymbols.set(node, symbol);
+            return;
+        }
+        let binding = globals.get(node.name);
+        if (!binding) {
+            binding = { name: node.name, references: [] };
+            globals.set(node.name, binding);
+        }
+        binding.references.push(node);
+    }
+    // ラベルはブロック内での宣言位置に関わらずブロック全体から参照できる
+    // （前方goto）ため、通常の宣言文と違い先読みで登録する。
+    function hoistLabels(body, scope) {
+        body.forEach((statement) => {
+            if (statement.type === "LabelStatement") {
+                declareLabel(scope, statement.label);
+            }
+        });
+    }
+    function resolveBlock(body, scope) {
+        hoistLabels(body, scope);
+        body.forEach((statement) => {
+            resolveStatement(statement, scope);
+        });
+    }
+    function resolveStatement(statement, scope) {
+        switch (statement.type) {
+            case "LocalStatement":
+                // 初期化式は新しいローカルが宣言される前の束縛で解決する
+                // （`local x = x` の右辺は外側のxを指す）
+                statement.init.forEach((expr) => {
+                    resolveExpression(expr, scope);
+                });
+                statement.variables.forEach((v) => declare(scope, v, "local"));
+                return;
+            case "AssignmentStatement":
+                statement.init.forEach((expr) => {
+                    resolveExpression(expr, scope);
+                });
+                statement.variables.forEach((v) => {
+                    if (v.type === "Identifier") {
+                        reference(scope, v);
+                    }
+                    else {
+                        resolveExpression(v, scope);
+                    }
+                });
+                return;
+            case "CallStatement":
+                resolveExpression(statement.expression, scope);
+                return;
+            case "DoStatement": {
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "WhileStatement": {
+                resolveExpression(statement.condition, scope);
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "RepeatStatement": {
+                // `until`の条件式は本体で宣言されたローカルを参照できる
+                const inner = createScope("block", scope);
+                resolveBlock(statement.body, inner);
+                resolveExpression(statement.condition, inner);
+                return;
+            }
+            case "IfStatement":
+                statement.clauses.forEach((clause) => {
+                    if (clause.type !== "ElseClause") {
+                        resolveExpression(clause.condition, scope);
+                    }
+                    const inner = createScope("block", scope);
+                    resolveBlock(clause.body, inner);
+                });
+                return;
+            case "ForNumericStatement": {
+                resolveExpression(statement.start, scope);
+                resolveExpression(statement.end, scope);
+                if (statement.step) {
+                    resolveExpression(statement.step, scope);
+                }
+                const inner = createScope("block", scope);
+                declare(inner, statement.variable, "for");
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "ForGenericStatement": {
+                statement.iterators.forEach((iterator) => {
+                    resolveExpression(iterator, scope);
+                });
+                const inner = createScope("block", scope);
+                statement.variables.forEach((v) => declare(inner, v, "for"));
+                resolveBlock(statement.body, inner);
+                return;
+            }
+            case "FunctionDeclaration":
+                resolveFunctionDeclaration(statement, scope);
+                return;
+            case "ReturnStatement":
+                statement.arguments.forEach((argument) => {
+                    resolveExpression(argument, scope);
+                });
+                return;
+            case "BreakStatement":
+                return;
+            case "LabelStatement":
+                // hoistLabelsで宣言済みのため、ここでは何もしない
+                return;
+            case "GotoStatement": {
+                const symbol = lookupLabel(scope, statement.label.name);
+                if (symbol) {
+                    symbol.references.push(statement.label);
+                    identifierSymbols.set(statement.label, symbol);
+                }
+                return;
+            }
+            default: {
+                const exhaustive = statement;
+                throw new TypeError("Unknown statement type: `" + JSON.stringify(exhaustive) + "`");
+            }
+        }
+    }
+    function resolveFunctionDeclaration(fn, scope) {
+        if (fn.identifier) {
+            if (fn.identifier.type === "Identifier") {
+                if (fn.isLocal) {
+                    // `local function`は再帰呼び出しのため、本体を解決する前に自身を宣言する
+                    declare(scope, fn.identifier, "local");
+                }
+                else {
+                    // 非local: 既存のローカル/グローバルへの代入として扱う（新規宣言ではない）
+                    reference(scope, fn.identifier);
+                }
+            }
+            else {
+                resolveExpression(fn.identifier, scope);
+            }
+        }
+        const inner = createScope("function", scope);
+        fn.parameters.forEach((parameter) => {
+            if (parameter.type === "Identifier") {
+                declare(inner, parameter, "param");
+            }
+        });
+        resolveBlock(fn.body, inner);
+    }
+    function resolveExpression(expr, scope) {
+        switch (expr.type) {
+            case "Identifier":
+                reference(scope, expr);
+                return;
+            case "StringLiteral":
+            case "NumericLiteral":
+            case "BooleanLiteral":
+            case "NilLiteral":
+            case "VarargLiteral":
+                return;
+            case "LogicalExpression":
+            case "BinaryExpression":
+                resolveExpression(expr.left, scope);
+                resolveExpression(expr.right, scope);
+                return;
+            case "UnaryExpression":
+                resolveExpression(expr.argument, scope);
+                return;
+            case "CallExpression":
+                resolveExpression(expr.base, scope);
+                expr.arguments.forEach((argument) => {
+                    resolveExpression(argument, scope);
+                });
+                return;
+            case "TableCallExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.arguments, scope);
+                return;
+            case "StringCallExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.argument, scope);
+                return;
+            case "IndexExpression":
+                resolveExpression(expr.base, scope);
+                resolveExpression(expr.index, scope);
+                return;
+            case "MemberExpression":
+                resolveExpression(expr.base, scope);
+                // フィールド名（`.identifier`）は変数参照ではないため解決しない
+                return;
+            case "FunctionDeclaration": {
+                const inner = createScope("function", scope);
+                expr.parameters.forEach((parameter) => {
+                    if (parameter.type === "Identifier") {
+                        declare(inner, parameter, "param");
+                    }
+                });
+                resolveBlock(expr.body, inner);
+                return;
+            }
+            case "TableConstructorExpression":
+                expr.fields.forEach((field) => {
+                    if (field.type === "TableKey") {
+                        resolveExpression(field.key, scope);
+                        resolveExpression(field.value, scope);
+                    }
+                    else if (field.type === "TableValue") {
+                        resolveExpression(field.value, scope);
+                    }
+                    else {
+                        // TableKeyString: キー名（`{ key = value }`のkey）は変数参照ではない
+                        resolveExpression(field.value, scope);
+                    }
+                });
+                return;
+            default: {
+                const exhaustive = expr;
+                throw new TypeError("Unknown expression type: `" + JSON.stringify(exhaustive) + "`");
+            }
+        }
+    }
+    const chunkScope = createScope("chunk", null);
+    resolveBlock(chunk.body, chunkScope);
+    return {
+        chunkScope,
+        symbols: allSymbols,
+        globals,
+        symbolOf: (identifier) => identifierSymbols.get(identifier),
+    };
+}

package/eslint.config.js

@@ -0,0 +1,29 @@
+// @ts-check
+const eslint = require("@eslint/js");
+const tseslint = require("typescript-eslint");
+const globals = require("globals");
+const eslintConfigPrettier = require("eslint-config-prettier");
+
+module.exports = tseslint.config(
+  {
+    ignores: ["dist/**"],
+  },
+  {
+    files: ["src/**/*.ts", "test/**/*.ts"],
+    extends: [
+      eslint.configs.recommended,
+      ...tseslint.configs.strictTypeChecked,
+      ...tseslint.configs.stylistic,
+    ],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        project: "./tsconfig.eslint.json",
+        tsconfigRootDir: __dirname,
+      },
+    },
+  },
+  eslintConfigPrettier,
+);

package/package.json

@@ -1,27 +1,33 @@
-{
-  "name": "storm-lua-minify",
-  "description": "A Lua minifier also outputs source map",
-  "version": "0.1.2",
-  "dependencies": {
-    "commander": "^12.1.0",
-    "luamin": "^1.0.4",
-    "luaparse": "^0.3.1",
-    "source-map": "^0.7.4"
-  },
-  "devDependencies": {
-    "@types/node": "^20.12.8",
-    "@types/luaparse": "^0.2.12",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "eslint": "^8.57.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
-  },
-  "bin": "dist/cli.js",
-  "scripts": {
-    "start": "node ./dist/index.js",
-    "build": "npx tsc"
-  },
-  "author": "Nona Takahara <nona_t_2612@yahoo.co.jp>",
-  "license": "MIT"
-}
+{
+  "name": "storm-lua-minify",
+  "description": "A Lua minifier also outputs source map",
+  "version": "0.2.0",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "luaparse": "^0.3.1",
+    "source-map": "^0.7.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/node": "^22.20.1",
+    "@types/luaparse": "^0.2.13",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.7.0",
+    "prettier": "^3.9.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.63.0"
+  },
+  "bin": "dist/cli.js",
+  "scripts": {
+    "start": "node ./dist/index.js",
+    "build": "npx tsc",
+    "test": "node -r ts-node/register/transpile-only --test \"test/**/*.test.ts\"",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "author": "Nona Takahara <nona_t_2612@yahoo.co.jp>",
+  "license": "MIT"
+}