storm-lua-minify 0.3.0 → 0.9.0

package/dist/ast2lua.js

@@ -8,6 +8,7 @@ const source_map_1 = require("source-map");
 const linker_1 = require("./linker");
 const keywordLocator_1 = require("./keywordLocator");
 const transform_1 = require("./transform");
+const sourceMetadata_1 = require("./sourceMetadata");
 const PRECEDENCE = {
     or: 1,
     and: 2,
@@ -137,6 +138,10 @@ function isKeyword(id) {
     }
     return false;
 }
+// 末尾が16進整数リテラル（0x/0Xの後に16進数字が1つ以上続く）かどうか。
+// a〜fは識別子の文字集合とも重なるため、isNeedSeparatorのalpha分岐だけでは
+// 区別できない（#53）。
+const HEX_INT_LITERAL_TAIL = /0[xX][0-9a-fA-F]+$/;
 function isNeedSeparator(a, b) {
     const lastCharA = a.slice(-1);
     const firstCharB = b.charAt(0);
@@ -152,11 +157,15 @@ function isNeedSeparator(a, b) {
             // e.g. `local a` + `local b`
             return true;
         }
-        else {
-            // e.g. `not` + `(2>3 or 3<2)`
-            // e.g. `x` + `^`
-            return false;
+        if (firstCharB == "." && HEX_INT_LITERAL_TAIL.test(a)) {
+            // e.g. `0xff` + `..` : 16進の浮動小数点(`0xff.8`)も読めてしまうため、
+            // 続く`.`をそのまま出すと`0xff.`まで数値として読まれ、10進では起きない
+            // 区切り落ち（malformed number）になる（#53）。
+            return true;
         }
+        // e.g. `not` + `(2>3 or 3<2)`
+        // e.g. `x` + `^`
+        return false;
     }
     if (regexDigits.test(lastCharA)) {
         if (firstCharB == "(" ||
@@ -184,7 +193,18 @@ function isNeedSeparator(a, b) {
     }
     return false;
 }
-function addWithSeparator(val, adding, separator = " ") {
+const requiredWhitespaceByNode = new WeakMap();
+function whitespaceOf(...values) {
+    for (const value of values) {
+        if (value instanceof source_map_1.SourceNode) {
+            const whitespace = requiredWhitespaceByNode.get(value);
+            if (whitespace)
+                return whitespace;
+        }
+    }
+    return "\n";
+}
+function addWithSeparator(val, adding, separator = whitespaceOf(val)) {
     if (isNeedSeparator(val.toString(), wrapArray(adding)
         .map((p) => p.toString())
         .join())) {
@@ -193,7 +213,7 @@ function addWithSeparator(val, adding, separator = " ") {
     val.add(adding);
     return val;
 }
-function prependWithSeparator(val, prepending, separator = " ") {
+function prependWithSeparator(val, prepending, separator = whitespaceOf(val)) {
     if (isNeedSeparator(wrapArray(prepending)
         .map((p) => p.toString())
         .join(), val.toString())) {
@@ -202,7 +222,7 @@ function prependWithSeparator(val, prepending, separator = " ") {
     val.prepend(prepending);
     return val;
 }
-function insertSeparator(a, b, separator = " ") {
+function insertSeparator(a, b, separator = whitespaceOf(a, b)) {
     return isNeedSeparator(a.toString(), b.toString()) ? separator : undefined;
 }
 class MinifyFile {
@@ -211,28 +231,29 @@ class MinifyFile {
     ast;
     minifier;
     mode;
+    requiredWhitespace;
     constructor(fileName, moduleName, ast, minifier, mode) {
         this.fileName = fileName;
         this.moduleName = moduleName;
         this.ast = ast;
         this.minifier = minifier;
         this.mode = mode;
+        this.requiredWhitespace = mode.requiredWhitespace ?? "\n";
     }
-    parse(noComment) {
+    /** 合成文同士の境界も、通常の文リストと同じ区切り判定で出力する。 */
+    printGeneratedStatements(statements) {
+        return this.formatStatementList(statements);
+    }
+    parse() {
         const body = this.formatStatementList(this.ast.body);
-        if (!noComment && this.ast.comments) {
-            const comments = this.ast.comments;
-            comments
-                .reverse()
-                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
-                .forEach((comment) => {
-                body.prepend([this.sourceNodeHelper(comment, comment.raw), "\n"]);
-            });
-            return body;
-        }
-        else {
-            return body;
-        }
+        this.minifier
+            .getSourceMetadata(this.moduleName)
+            .afterModuleComments()
+            .filter(sourceMetadata_1.isPreservedComment)
+            .forEach((comment) => {
+            body.add(["\n", this.sourceNodeHelper(comment, comment.raw)]);
+        });
+        return body;
     }
     /**
      * モジュール本体の最後の文が「単一の式を返すreturn文」であるときに限り、
@@ -240,7 +261,7 @@ class MinifyFile {
      * 展開したい呼び出し側（#29のレビュー対応）が利用する。
      * 該当しない場合はundefinedを返し、呼び出し側はIIFE方式へフォールバックする。
      */
-    parseAsStatementsAndFinalExpression(noComment) {
+    parseAsStatementsAndFinalExpression() {
         const body = this.ast.body;
         const last = body[body.length - 1];
         if (!last ||
@@ -249,18 +270,20 @@ class MinifyFile {
             return undefined;
         }
         const statements = this.formatStatementList(body.slice(0, -1));
-        if (!noComment && this.ast.comments) {
-            this.ast.comments
-                .slice()
-                .reverse()
-                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
-                .forEach((comment) => {
-                statements.prepend([
-                    this.sourceNodeHelper(comment, comment.raw),
-                    "\n",
-                ]);
-            });
-        }
+        const metadata = this.minifier.getSourceMetadata(this.moduleName);
+        [
+            ...metadata.beforeOf(last),
+            ...metadata.trailingOf(last),
+            ...metadata.afterModuleComments(),
+        ]
+            .filter(sourceMetadata_1.isPreservedComment)
+            .forEach((comment) => {
+            statements.add([
+                "\n",
+                this.sourceNodeHelper(comment, comment.raw),
+                "\n",
+            ]);
+        });
         const finalExpression = this.formatExpression(last.arguments[0]);
         return { statements, finalExpression };
     }
@@ -269,7 +292,9 @@ class MinifyFile {
         const column = node?.loc?.start.column;
         // this.fileNameは常にこのMinifyFileインスタンスが担当するモジュール自身の
         // ファイル名（Linkパスで解決済み）なので、ここで出力するノードの由来ファイルとして正しい。
-        return new source_map_1.SourceNode(line == undefined ? null : line, column == undefined ? null : column, this.fileName, chuncks, name);
+        const sourceNode = new source_map_1.SourceNode(line == undefined ? null : line, column == undefined ? null : column, this.fileName, chuncks, name);
+        requiredWhitespaceByNode.set(sourceNode, this.requiredWhitespace);
+        return sourceNode;
     }
     _keywordLocator;
     /**
@@ -296,6 +321,9 @@ class MinifyFile {
      * （入れ子の`if...then`等）を誤って拾うことはない。
      */
     keywordAfter(anchor, value) {
+        if (!anchor.loc?.end) {
+            return this.sourceNodeHelper(undefined, value);
+        }
         return this.keywordFrom(anchor.loc?.end, value);
     }
     keywordFrom(from, value) {
@@ -314,8 +342,29 @@ class MinifyFile {
     }
     formatStatementList(body) {
         const result = this.sourceNodeHelper(undefined, []);
+        const metadata = this.minifier.getSourceMetadata(this.moduleName);
         wrapArray(body).forEach((statement) => {
-            addWithSeparator(result, this.formatStatement(statement), "\n");
+            const statementNode = this.sourceNodeHelper(undefined, []);
+            const sourceStatement = statement.type === "ModuleSplice" ? undefined : statement;
+            (sourceStatement ? metadata.beforeOf(sourceStatement) : [])
+                .filter(sourceMetadata_1.isPreservedComment)
+                .forEach((comment) => {
+                statementNode.add([
+                    this.sourceNodeHelper(comment, comment.raw),
+                    "\n",
+                ]);
+            });
+            statementNode.add(this.formatStatement(statement));
+            (sourceStatement ? metadata.trailingOf(sourceStatement) : [])
+                .filter(sourceMetadata_1.isPreservedComment)
+                .forEach((comment) => {
+                statementNode.add([
+                    this.requiredWhitespace,
+                    this.sourceNodeHelper(comment, comment.raw),
+                    "\n",
+                ]);
+            });
+            addWithSeparator(result, statementNode, "\n");
         });
         return result;
     }
@@ -330,7 +379,7 @@ class MinifyFile {
      * （呼び出し側は従来のIIFE方式にフォールバックする）。
      */
     trySpliceRequireStatement(statement) {
-        if (this.mode.moduleLikeLua) {
+        if (this.mode.requireWrapper) {
             return undefined;
         }
         if (statement.variables.length !== 1 || statement.init.length !== 1) {
@@ -351,7 +400,10 @@ class MinifyFile {
             : this.formatExpression(target);
         const result = this.sourceNodeHelper(statement, []);
         addWithSeparator(result, spliced.statements);
-        addWithSeparator(result, isLocal ? ["local ", targetNode] : [targetNode]);
+        if (isLocal) {
+            addWithSeparator(result, "local");
+        }
+        addWithSeparator(result, targetNode);
         addWithSeparator(result, "=");
         addWithSeparator(result, spliced.finalExpression);
         return result;
@@ -362,16 +414,26 @@ class MinifyFile {
      * 近い、LifeBoat Modeでの一般的な使い方に合わせるための対応。#29のレビュー対応）。
      */
     tryInlineBareRequireStatement(expr) {
-        if (this.mode.moduleLikeLua) {
+        if (this.mode.requireWrapper) {
             return undefined;
         }
         const moduleRef = this.matchModuleCallExpression(expr);
         if (!moduleRef || moduleRef.kind !== "require") {
             return undefined;
         }
+        // 戻り値を使わないrequireでは、依存モジュール末尾のreturn式も不要になる。
+        // return文ごと展開すると呼び出し元を途中でreturnし、後続文がある場合は
+        // 構文上も不正になるため、分離可能なら副作用を持つ先行文だけを出力する。
+        const spliced = this.minifier.splitModuleForStatementSplice(moduleRef.moduleName);
+        if (spliced) {
+            return spliced.statements;
+        }
         return this.minifier.printModuleInline(moduleRef.moduleName);
     }
     formatStatement(statement) {
+        if (statement.type === "ModuleSplice") {
+            return this.minifier.printModuleInline(statement.moduleName);
+        }
         if (statement.type == "AssignmentStatement" ||
             statement.type == "LocalStatement") {
             const spliced = this.trySpliceRequireStatement(statement);
@@ -396,10 +458,8 @@ class MinifyFile {
             const variables = statement.variables
                 .map((variable) => [this.formatExpression(variable), ","])
                 .flat();
-            const result = this.sourceNodeHelper(statement, [
-                "local ",
-                this.sourceNodeHelper(undefined, variables.slice(0, -1)),
-            ]);
+            const result = this.sourceNodeHelper(statement, "local");
+            addWithSeparator(result, this.sourceNodeHelper(undefined, variables.slice(0, -1)));
             if (statement.init.length) {
                 const inits = statement.init
                     .map((init) => [this.formatExpression(init), ","])
@@ -480,7 +540,10 @@ class MinifyFile {
             return result;
         }
         else if (statement.type == "FunctionDeclaration") {
-            const result = this.sourceNodeHelper(statement, (statement.isLocal ? "local " : "") + "function ");
+            const result = this.sourceNodeHelper(statement, statement.isLocal ? "local" : "function");
+            if (statement.isLocal) {
+                addWithSeparator(result, "function");
+            }
             if (statement.identifier) {
                 addWithSeparator(result, this.formatExpression(statement.identifier));
             }
@@ -547,10 +610,9 @@ class MinifyFile {
         }
         else if (statement.type == "GotoStatement") {
             // The identifier names in a `GotoStatement` can safely be renamed
-            return this.sourceNodeHelper(statement, [
-                "goto ",
-                this.generateIdentifier(statement.label),
-            ]);
+            const result = this.sourceNodeHelper(statement, "goto");
+            addWithSeparator(result, this.generateIdentifier(statement.label));
+            return result;
         }
         else {
             throw TypeError("Unknown statement type: `" + JSON.stringify(statement) + "`");
@@ -563,8 +625,13 @@ class MinifyFile {
         if (expression.type == "Identifier") {
             return this.generateIdentifier(expression);
         }
-        else if (expression.type == "StringLiteral" ||
-            expression.type == "NumericLiteral" ||
+        else if (expression.type == "StringLiteral") {
+            const fieldRename = this.minifier.getFieldRename(expression);
+            return fieldRename
+                ? this.sourceNodeHelper(expression, JSON.stringify(fieldRename.name), fieldRename.originalName)
+                : this.sourceNodeHelper(expression, expression.raw);
+        }
+        else if (expression.type == "NumericLiteral" ||
             expression.type == "BooleanLiteral" ||
             expression.type == "NilLiteral" ||
             expression.type == "VarargLiteral") {
@@ -593,7 +660,11 @@ class MinifyFile {
             if (operator == "^" || operator == "..") {
                 associativity = "right";
             }
-            else if (currentPrecedence < options.precedence ||
+            // 上のif（結合則の決定）とは独立に判定する必要がある。else ifだと`^`と`..`が
+            // ここに来ず、優先順位の高い演算子の中に現れても丸括弧が付かなくなる
+            // （#52。例: `0.5 % (2 .. 16)`が`0.5%2 ..16`になり、`%`の方が優先順位が
+            // 高いため意味の違うコードとして読み直されてしまっていた）。
+            if (currentPrecedence < options.precedence ||
                 (currentPrecedence == options.precedence &&
                     associativity != options.direction &&
                     options.parent != "+" &&
@@ -686,12 +757,15 @@ class MinifyFile {
             ]);
         }
         else if (expression.type == "MemberExpression") {
+            const fieldRename = this.minifier.getFieldRename(expression.identifier);
             return this.sourceNodeHelper(expression, [
                 this.formatBase(expression.base),
                 expression.indexer,
-                this.formatExpression(expression.identifier, {
-                    preserveIdentifiers: true,
-                }),
+                fieldRename
+                    ? this.sourceNodeHelper(expression.identifier, fieldRename.name, fieldRename.originalName)
+                    : this.formatExpression(expression.identifier, {
+                        preserveIdentifiers: true,
+                    }),
             ]);
         }
         else if (expression.type == "FunctionDeclaration") {
@@ -742,8 +816,13 @@ class MinifyFile {
                 else {
                     // at this point, `field.type == 'TableKeyString'`
                     // TODO: keep track of nested scopes (#18)
+                    const fieldRename = this.minifier.getFieldRename(field.key);
                     return this.sourceNodeHelper(field, [
-                        this.formatExpression(field.key, { preserveIdentifiers: true }),
+                        fieldRename
+                            ? this.sourceNodeHelper(field.key, fieldRename.name, fieldRename.originalName)
+                            : this.formatExpression(field.key, {
+                                preserveIdentifiers: true,
+                            }),
                         "=",
                         this.formatExpression(field.value),
                         comma,
@@ -759,16 +838,25 @@ class MinifyFile {
             throw TypeError("Unknown expression type: `" + JSON.stringify(expression) + "`");
         }
     }
+    /**
+     * インデックス・メンバー参照・呼び出しの基底を出力する。
+     *
+     * Luaの文法で基底にそのまま置けるのは、変数・インデックス式・関数呼び出しだけで
+     * ある。それ以外の式は丸括弧で包まないと基底に置けない（`3 .x` も `"a":upper()`
+     * も構文エラーになる）。そのため、包む必要のある型を数え上げるのではなく、
+     * そのまま置ける形かどうかだけを見る。式の種類が増えても、元のソースには現れない
+     * 式を基底へ置く変換（定数畳み込みなど）が入っても、この判定だけで正しい括弧が付く。
+     */
     formatBase(base) {
         const type = base.type;
-        const needsParens = type == "CallExpression" ||
-            type == "BinaryExpression" ||
-            type == "FunctionDeclaration" ||
-            type == "TableConstructorExpression" ||
-            type == "LogicalExpression" ||
-            type == "StringLiteral";
+        const canStandAsBase = type == "Identifier" ||
+            type == "MemberExpression" ||
+            type == "IndexExpression" ||
+            type == "CallExpression" ||
+            type == "StringCallExpression" ||
+            type == "TableCallExpression";
         const result = this.sourceNodeHelper(base, this.formatExpression(base));
-        if (needsParens) {
+        if (!canStandAsBase) {
             prependWithSeparator(result, "(");
             addWithSeparator(result, ")");
         }
@@ -805,16 +893,16 @@ class MinifyFile {
             // dofileは呼び出しごとに毎回展開しなおす（キャッシュしない）
             return this.minifier.printModuleInline(ref.moduleName);
         }
-        if (!this.mode.moduleLikeLua) {
+        if (!this.mode.requireWrapper) {
             // SLモード（無オプション）: requireもキャッシュせずその場展開する
             // （挙動互換性のため、ホイストした共有ローカルへの参照にはしない）。
             // 式の位置に置けるようにIIFEで包む。
             const body = this.minifier.printModuleInline(ref.moduleName);
-            return this.sourceNodeHelper(expression, [
-                "(function() ",
-                body,
-                " end)()",
-            ]);
+            const result = this.sourceNodeHelper(expression, "(function()");
+            addWithSeparator(result, body);
+            addWithSeparator(result, "end");
+            result.add(")()");
+            return result;
         }
         // -mモードのrequireはそのまま呼び出しとして出力し、実行時のrequire関数に委ねる
         return undefined;

package/dist/astWalk.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkStatement = walkStatement;
+exports.walkExpression = walkExpression;
+exports.walkBlockDeep = walkBlockDeep;
+function walkStatement(statement, visitor) {
+    visitor.onStatement?.(statement);
+    switch (statement.type) {
+        case "LocalStatement":
+            statement.init.forEach((expr) => {
+                walkExpression(expr, visitor);
+            });
+            return;
+        case "AssignmentStatement":
+            statement.variables.forEach((variable) => {
+                if (variable.type === "Identifier") {
+                    visitor.onIdentifierReference?.(variable);
+                }
+                else {
+                    walkExpression(variable, visitor);
+                }
+            });
+            statement.init.forEach((expr) => {
+                walkExpression(expr, visitor);
+            });
+            return;
+        case "CallStatement":
+            walkExpression(statement.expression, visitor);
+            return;
+        case "DoStatement":
+            visitor.onBlock?.(statement.body);
+            return;
+        case "WhileStatement":
+            walkExpression(statement.condition, visitor);
+            visitor.onBlock?.(statement.body);
+            return;
+        case "RepeatStatement":
+            visitor.onBlock?.(statement.body);
+            walkExpression(statement.condition, visitor);
+            return;
+        case "IfStatement":
+            statement.clauses.forEach((clause) => {
+                if (clause.type !== "ElseClause") {
+                    walkExpression(clause.condition, visitor);
+                }
+                visitor.onBlock?.(clause.body);
+            });
+            return;
+        case "ForNumericStatement":
+            walkExpression(statement.start, visitor);
+            walkExpression(statement.end, visitor);
+            if (statement.step)
+                walkExpression(statement.step, visitor);
+            visitor.onBlock?.(statement.body);
+            return;
+        case "ForGenericStatement":
+            statement.iterators.forEach((iterator) => {
+                walkExpression(iterator, visitor);
+            });
+            visitor.onBlock?.(statement.body);
+            return;
+        case "FunctionDeclaration":
+            if (statement.identifier) {
+                if (statement.identifier.type === "Identifier") {
+                    if (!statement.isLocal) {
+                        visitor.onIdentifierReference?.(statement.identifier);
+                    }
+                }
+                else {
+                    walkExpression(statement.identifier, visitor);
+                }
+            }
+            visitor.onFunction?.(statement);
+            visitor.onBlock?.(statement.body);
+            return;
+        case "ReturnStatement":
+            statement.arguments.forEach((argument) => {
+                walkExpression(argument, visitor);
+            });
+            return;
+        case "BreakStatement":
+        case "LabelStatement":
+        case "GotoStatement":
+            return;
+        default: {
+            const exhaustive = statement;
+            throw new TypeError("Unknown statement type: `" + JSON.stringify(exhaustive) + "`");
+        }
+    }
+}
+function walkExpression(expression, visitor) {
+    visitor.onExpression?.(expression);
+    switch (expression.type) {
+        case "Identifier":
+            visitor.onIdentifierReference?.(expression);
+            return;
+        case "StringLiteral":
+        case "NumericLiteral":
+        case "BooleanLiteral":
+        case "NilLiteral":
+        case "VarargLiteral":
+            return;
+        case "LogicalExpression":
+        case "BinaryExpression":
+            walkExpression(expression.left, visitor);
+            walkExpression(expression.right, visitor);
+            return;
+        case "UnaryExpression":
+            walkExpression(expression.argument, visitor);
+            return;
+        case "CallExpression":
+            walkExpression(expression.base, visitor);
+            expression.arguments.forEach((argument) => {
+                walkExpression(argument, visitor);
+            });
+            return;
+        case "TableCallExpression":
+            walkExpression(expression.base, visitor);
+            walkExpression(expression.arguments, visitor);
+            return;
+        case "StringCallExpression":
+            walkExpression(expression.base, visitor);
+            walkExpression(expression.argument, visitor);
+            return;
+        case "IndexExpression":
+            walkExpression(expression.base, visitor);
+            walkExpression(expression.index, visitor);
+            return;
+        case "MemberExpression":
+            walkExpression(expression.base, visitor);
+            return;
+        case "FunctionDeclaration":
+            visitor.onFunction?.(expression);
+            visitor.onBlock?.(expression.body);
+            return;
+        case "TableConstructorExpression":
+            expression.fields.forEach((field) => {
+                if (field.type === "TableKey") {
+                    walkExpression(field.key, visitor);
+                }
+                walkExpression(field.value, visitor);
+            });
+            return;
+        default: {
+            const exhaustive = expression;
+            throw new TypeError("Unknown expression type: `" + JSON.stringify(exhaustive) + "`");
+        }
+    }
+}
+/** Walk a complete execution tree while preserving the shared node classification above. */
+function walkBlockDeep(body, visitor) {
+    const deepVisitor = {
+        ...visitor,
+        onBlock: (nested) => {
+            visitor.onBlock?.(nested);
+            walkBlockDeep(nested, visitor);
+        },
+    };
+    body.forEach((statement) => {
+        walkStatement(statement, deepVisitor);
+    });
+}