storm-lua-minify 0.3.0 → 0.9.1

package/dist/optimizerPass.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNCHANGED = exports.PassOrchestrator = void 0;
+const resolver_1 = require("./resolver");
+/**
+ * AST変換と解析世代を結び付ける最小のpass orchestrator。
+ *
+ * 構造変更後の古いResolveResultやoptimizer factを後続passへ渡さないことが
+ * 第一の不変条件である。AST世代はあらゆる変更で進み、Resolve世代は束縛を
+ * 変える変更だけで進む。この区別により、安価な解析を不必要に再Resolveせず、
+ * ASTを参照するcacheだけは確実に失効させる。
+ */
+class PassOrchestrator {
+    chunk;
+    resolvedValue;
+    astGenerationValue = 0;
+    resolveGenerationValue = 0;
+    recordsValue = [];
+    analysisCache = new Map();
+    constructor(chunk, initialResolve) {
+        this.chunk = chunk;
+        this.resolvedValue = initialResolve;
+    }
+    get resolved() {
+        return this.resolvedValue;
+    }
+    get resolveGeneration() {
+        return this.resolveGenerationValue;
+    }
+    get astGeneration() {
+        return this.astGenerationValue;
+    }
+    get records() {
+        return this.recordsValue;
+    }
+    /**
+     * 現在のAST世代に束縛された解析を遅延生成する。
+     *
+     * cache keyは解析種別とpolicyの組を表す安定したobjectにする。ASTを変更したpassが
+     * 一つでも走れば、Resolveの再計算要否にかかわらずcacheは破棄される。
+     */
+    analysis(key, analyze) {
+        const cached = this.analysisCache.get(key);
+        if (cached?.generation === this.astGenerationValue) {
+            return cached.value;
+        }
+        const value = analyze(this.chunk, this.resolvedValue, this.astGenerationValue);
+        if (value.generation !== this.astGenerationValue) {
+            throw new Error("Analysis was built for a stale AST generation");
+        }
+        this.analysisCache.set(key, {
+            generation: this.astGenerationValue,
+            value,
+        });
+        return value;
+    }
+    run(name, transform) {
+        const astBefore = this.astGenerationValue;
+        const resolveBefore = this.resolveGenerationValue;
+        const result = transform(this.resolvedValue);
+        if (!result.changed && result.invalidatesResolve) {
+            throw new Error(`Pass ${name} cannot invalidate Resolve without changing the AST`);
+        }
+        if (result.changed) {
+            this.astGenerationValue++;
+            this.analysisCache.clear();
+        }
+        if (result.invalidatesResolve) {
+            this.resolvedValue = (0, resolver_1.resolveScopes)(this.chunk);
+            this.resolveGenerationValue++;
+        }
+        this.recordsValue.push({
+            name,
+            ...result,
+            astGenerationBefore: astBefore,
+            astGenerationAfter: this.astGenerationValue,
+            resolveGenerationBefore: resolveBefore,
+            resolveGenerationAfter: this.resolveGenerationValue,
+        });
+        return result;
+    }
+    runUntilStable(name, transform) {
+        const results = [];
+        for (let iteration = 0;; iteration++) {
+            const result = this.run(`${name}:${String(iteration)}`, (resolved) => transform(resolved, iteration));
+            results.push(result);
+            if (!result.changed)
+                return results;
+        }
+    }
+}
+exports.PassOrchestrator = PassOrchestrator;
+exports.UNCHANGED = {
+    changed: false,
+    invalidatesResolve: false,
+};

package/dist/optimizerTransaction.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTransactionalMinifierVariant = selectTransactionalMinifierVariant;
+const minifier_1 = require("./minifier");
+function renderVariant(request, mode) {
+    // Minifier instanceを共有しないことがrollbackの不変条件。ASTだけでなく
+    // Resolve、SourceMetadata、annotation、rename cache、module予約名も分離する。
+    const output = new minifier_1.Minifier(request.entryFilePath, request.luaParseSettings, mode)
+        .parse()
+        .toStringWithSourceMap({
+        file: request.outputFile ?? "main.min.lua",
+    });
+    return {
+        code: output.code,
+        sourceMap: output.map.toString(),
+        byteLength: new TextEncoder().encode(output.code).length,
+    };
+}
+/**
+ * baselineとtrialを最終Rename/Printまで同条件で評価し、厳密に短いtrialだけを選ぶ。
+ * trialは隔離されたMinifier上で動くため、失敗・同長・増加時に復元操作は不要。
+ */
+function selectTransactionalMinifierVariant(request) {
+    const baseline = renderVariant(request, request.baselineMode);
+    let trial;
+    try {
+        trial = renderVariant(request, request.trialMode);
+    }
+    catch (trialError) {
+        return {
+            accepted: false,
+            reason: "trial-failed",
+            selected: baseline,
+            baseline,
+            trialError,
+            byteSavings: 0,
+        };
+    }
+    if (trial.byteLength >= baseline.byteLength) {
+        return {
+            accepted: false,
+            reason: "not-shorter",
+            selected: baseline,
+            baseline,
+            trial,
+            byteSavings: 0,
+        };
+    }
+    return {
+        accepted: true,
+        selected: trial,
+        baseline,
+        trial,
+        byteSavings: baseline.byteLength - trial.byteLength,
+    };
+}

package/dist/optimizerValueDomain.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_OPTIMIZER_TUPLE = exports.EMPTY_OPTIMIZER_VALUE = exports.NIL_ATOM = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS = void 0;
+exports.finiteOptimizerValue = finiteOptimizerValue;
+exports.unknownOptimizerValue = unknownOptimizerValue;
+exports.joinOptimizerValues = joinOptimizerValues;
+exports.finiteOptimizerTuple = finiteOptimizerTuple;
+exports.valueAtOptimizerTupleSlot = valueAtOptimizerTupleSlot;
+exports.joinOptimizerTuples = joinOptimizerTuples;
+exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS = Object.freeze({
+    maxAtoms: 16,
+    maxUnknownReasons: 8,
+    maxTuplePrefix: 16,
+});
+exports.NIL_ATOM = Object.freeze({ kind: "nil" });
+exports.EMPTY_OPTIMIZER_VALUE = Object.freeze({
+    atoms: Object.freeze([]),
+    unknownReasons: Object.freeze([]),
+});
+exports.EMPTY_OPTIMIZER_TUPLE = Object.freeze({
+    prefix: Object.freeze([]),
+    tail: Object.freeze({ kind: "none" }),
+});
+function finiteOptimizerValue(atoms = [], unknownReasons = [], limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    validateCustomLimits(limits);
+    const normalizedAtoms = uniqueSorted(atoms, atomKey);
+    const normalizedReasons = uniqueSorted(unknownReasons, (reason) => reason);
+    const atomOverflow = normalizedAtoms.length > limits.maxAtoms;
+    const reasons = atomOverflow
+        ? capReasons([...normalizedReasons, "atom-cap-exceeded"], limits.maxUnknownReasons)
+        : capNormalizedReasons(normalizedReasons, limits.maxUnknownReasons);
+    return Object.freeze({
+        atoms: Object.freeze(normalizedAtoms.slice(0, limits.maxAtoms)),
+        unknownReasons: Object.freeze(reasons),
+    });
+}
+function unknownOptimizerValue(reason, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    return finiteOptimizerValue([], [reason], limits);
+}
+function joinOptimizerValues(values, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    return finiteOptimizerValue(values.flatMap((value) => value.atoms), values.flatMap((value) => value.unknownReasons), limits);
+}
+function finiteOptimizerTuple(prefix, tail = { kind: "none" }, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    validateCustomLimits(limits);
+    const normalizedPrefix = prefix
+        .slice(0, limits.maxTuplePrefix)
+        .map((value) => finiteOptimizerValue(value.atoms, value.unknownReasons, limits));
+    const normalizedTail = prefix.length > limits.maxTuplePrefix
+        ? joinTupleTails([
+            tail,
+            {
+                kind: "unknown",
+                reasons: ["tuple-prefix-cap-exceeded"],
+            },
+        ], limits)
+        : normalizeTail(tail, limits);
+    return Object.freeze({
+        prefix: Object.freeze(normalizedPrefix),
+        tail: normalizedTail,
+    });
+}
+function valueAtOptimizerTupleSlot(tuple, index, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    if (!Number.isInteger(index) || index < 0)
+        throw new RangeError("Tuple slot index must be a non-negative integer");
+    if (index < tuple.prefix.length)
+        return tuple.prefix[index];
+    switch (tuple.tail.kind) {
+        case "none":
+            return finiteOptimizerValue([exports.NIL_ATOM], [], limits);
+        case "vararg":
+            // A vararg may contain fewer values than the requested slot.
+            return joinOptimizerValues([tuple.tail.value, finiteOptimizerValue([exports.NIL_ATOM], [], limits)], limits);
+        case "unknown":
+            return finiteOptimizerValue([], tuple.tail.reasons, limits);
+    }
+}
+function joinOptimizerTuples(tuples, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
+    validateCustomLimits(limits);
+    if (tuples.length === 0)
+        return exports.EMPTY_OPTIMIZER_TUPLE;
+    const prefixLength = Math.min(Math.max(...tuples.map((tuple) => tuple.prefix.length)), limits.maxTuplePrefix);
+    const prefix = Array.from({ length: prefixLength }, (_, index) => joinOptimizerValues(tuples.map((tuple) => valueAtOptimizerTupleSlot(tuple, index, limits)), limits));
+    const overflow = tuples.some((tuple) => tuple.prefix.length > limits.maxTuplePrefix);
+    const tail = joinTupleTails([
+        ...tuples.map((tuple) => tuple.tail),
+        ...(overflow
+            ? [
+                {
+                    kind: "unknown",
+                    reasons: ["tuple-prefix-cap-exceeded"],
+                },
+            ]
+            : []),
+    ], limits);
+    return finiteOptimizerTuple(prefix, tail, limits);
+}
+function joinTupleTails(tails, limits) {
+    const unknownReasons = tails.flatMap((tail) => tail.kind === "unknown" ? tail.reasons : []);
+    if (unknownReasons.length > 0) {
+        return Object.freeze({
+            kind: "unknown",
+            reasons: Object.freeze(capReasons(unknownReasons, limits.maxUnknownReasons)),
+        });
+    }
+    const varargs = tails.filter((tail) => tail.kind === "vararg");
+    if (varargs.length === 0)
+        return Object.freeze({ kind: "none" });
+    const values = varargs.map((tail) => tail.value);
+    if (tails.some((tail) => tail.kind === "none")) {
+        values.push(finiteOptimizerValue([exports.NIL_ATOM], [], limits));
+    }
+    return Object.freeze({
+        kind: "vararg",
+        value: joinOptimizerValues(values, limits),
+    });
+}
+function normalizeTail(tail, limits) {
+    switch (tail.kind) {
+        case "none":
+            return Object.freeze({ kind: "none" });
+        case "vararg":
+            return Object.freeze({
+                kind: "vararg",
+                value: finiteOptimizerValue(tail.value.atoms, tail.value.unknownReasons, limits),
+            });
+        case "unknown":
+            return Object.freeze({
+                kind: "unknown",
+                reasons: Object.freeze(capReasons(tail.reasons, limits.maxUnknownReasons)),
+            });
+    }
+}
+function atomKey(atom) {
+    switch (atom.kind) {
+        case "nil":
+            return "0:nil";
+        case "boolean":
+            return `1:boolean:${atom.value ? "1" : "0"}`;
+        case "number":
+            return `2:number:${atom.raw}`;
+        case "string":
+            return `3:string:${JSON.stringify(atom.value)}`;
+        case "function":
+            return `4:function:${atom.id}`;
+        case "allocation":
+            return `5:allocation:${atom.allocationKind}:${atom.id}`;
+        case "parameter":
+            return `6:parameter:${String(atom.index).padStart(12, "0")}`;
+        case "external":
+            return `7:external:${atom.id}`;
+    }
+}
+function uniqueSorted(values, keyOf) {
+    if (values.length === 0)
+        return [];
+    if (values.length === 1)
+        return [values[0]];
+    if (values.length === 2) {
+        const firstKey = keyOf(values[0]);
+        const lastKey = keyOf(values[1]);
+        if (firstKey === lastKey)
+            return [values[1]];
+        return firstKey < lastKey ? [values[0], values[1]] : [values[1], values[0]];
+    }
+    const byKey = new Map();
+    values.forEach((value) => byKey.set(keyOf(value), value));
+    return [...byKey.entries()]
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([, value]) => value);
+}
+function capReasons(reasons, maximum) {
+    const normalized = uniqueSorted(reasons, (reason) => reason);
+    return capNormalizedReasons(normalized, maximum);
+}
+function capNormalizedReasons(normalized, maximum) {
+    if (normalized.length <= maximum)
+        return normalized;
+    if (maximum === 0)
+        return [];
+    return [
+        ...normalized.slice(0, Math.max(0, maximum - 1)),
+        "reason-cap-exceeded",
+    ];
+}
+function validateCustomLimits(limits) {
+    // The default is a module-owned frozen literal that satisfies the invariants.
+    // Nearly every optimizer value uses it, so do not enumerate its fields again.
+    if (limits !== exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS)
+        validateLimits(limits);
+}
+function validateLimits(limits) {
+    Object.entries(limits).forEach(([name, value]) => {
+        if (!Number.isInteger(value) || value < 0)
+            throw new RangeError(`${name} must be a non-negative integer`);
+    });
+    // At least one slot is necessary to preserve the fact that a cap discarded
+    // information. An empty reason set means the atom set is exhaustive.
+    if (limits.maxUnknownReasons === 0)
+        throw new RangeError("maxUnknownReasons must be at least one");
+}

package/dist/options.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizationLeafDefinitions = exports.optimizationOptionDefinitions = void 0;
+exports.resolveMinifierMode = resolveMinifierMode;
+exports.isOptimizationOptionKey = isOptimizationOptionKey;
+exports.optimizationOptionDefinitions = [
+    { key: "optimizations", name: "optimizations", defaultValue: undefined },
+    {
+        key: "identifierOptimizations",
+        name: "identifier-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "localRenaming",
+        name: "local-renaming",
+        parent: "identifierOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "localNameReuse",
+        name: "local-name-reuse",
+        parent: "identifierOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "globalRenaming",
+        name: "global-renaming",
+        parent: "identifierOptimizations",
+        defaultValue: false,
+    },
+    {
+        key: "fieldRenaming",
+        name: "field-renaming",
+        parent: "identifierOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "globalAliasing",
+        name: "global-aliasing",
+        parent: "identifierOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "statementOptimizations",
+        name: "statement-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "localDeclarationMerging",
+        name: "local-declaration-merging",
+        parent: "statementOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "localDeclarationHoisting",
+        name: "local-declaration-hoisting",
+        parent: "statementOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "tableReadMerging",
+        name: "table-read-merging",
+        parent: "statementOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "fieldSensitiveTableEffects",
+        name: "field-sensitive-table-effects",
+        parent: "statementOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "constantOptimizations",
+        name: "constant-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "constantExpressionEvaluation",
+        name: "constant-expression-evaluation",
+        parent: "constantOptimizations",
+        defaultValue: false,
+    },
+    {
+        key: "localConstantPropagation",
+        name: "local-constant-propagation",
+        parent: "constantOptimizations",
+        defaultValue: false,
+    },
+    {
+        key: "interproceduralConstantPropagation",
+        name: "interprocedural-constant-propagation",
+        parent: "constantOptimizations",
+        defaultValue: false,
+    },
+    {
+        key: "functionOptimizations",
+        name: "function-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "parameterPruning",
+        name: "parameter-pruning",
+        parent: "functionOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "functionInlining",
+        name: "function-inlining",
+        parent: "functionOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "functionSpecialization",
+        name: "function-specialization",
+        parent: "functionOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "objectOptimizations",
+        name: "object-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "fieldValuePropagation",
+        name: "field-value-propagation",
+        parent: "objectOptimizations",
+        defaultValue: true,
+    },
+    {
+        key: "deadCodeOptimizations",
+        name: "dead-code-optimizations",
+        parent: "optimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "unusedCodeRemoval",
+        name: "unused-code-removal",
+        parent: "deadCodeOptimizations",
+        defaultValue: undefined,
+    },
+    {
+        key: "unusedLocalRemoval",
+        name: "unused-local-removal",
+        parent: "unusedCodeRemoval",
+        defaultValue: true,
+    },
+    {
+        key: "unusedFunctionRemoval",
+        name: "unused-function-removal",
+        parent: "unusedCodeRemoval",
+        defaultValue: true,
+    },
+    {
+        key: "unusedFieldInitializerRemoval",
+        name: "unused-field-initializer-removal",
+        parent: "unusedCodeRemoval",
+        defaultValue: true,
+    },
+    {
+        key: "unusedExportRemoval",
+        name: "unused-export-removal",
+        parent: "deadCodeOptimizations",
+        defaultValue: true,
+    },
+];
+const definitionsByKey = new Map(exports.optimizationOptionDefinitions.map((definition) => [
+    definition.key,
+    definition,
+]));
+exports.optimizationLeafDefinitions = exports.optimizationOptionDefinitions.filter((definition) => definition.defaultValue !== undefined);
+function isOptionLayers(value) {
+    return "config" in value || "cli" in value || "defaults" in value;
+}
+function valueFromLayer(key, layer) {
+    let current = key;
+    while (current !== undefined) {
+        const value = layer[current];
+        if (value !== undefined)
+            return value;
+        const definition = definitionsByKey.get(current);
+        current =
+            definition && "parent" in definition ? definition.parent : undefined;
+    }
+    return undefined;
+}
+function resolveMinifierMode(layers) {
+    const normalized = isOptionLayers(layers)
+        ? layers
+        : { cli: layers };
+    const defaults = normalized.defaults ?? {};
+    const config = normalized.config ?? {};
+    const cli = normalized.cli ?? {};
+    const runtimeProfile = cli.runtimeProfile ??
+        config.runtimeProfile ??
+        defaults.runtimeProfile ??
+        "lua53";
+    const requireWrapper = cli.requireWrapper ??
+        config.requireWrapper ??
+        defaults.requireWrapper ??
+        false;
+    const resolved = {
+        ...defaults,
+        ...config,
+        ...cli,
+        requireWrapper,
+        runtimeProfile,
+    };
+    exports.optimizationLeafDefinitions.forEach((definition) => {
+        resolved[definition.key] =
+            valueFromLayer(definition.key, cli) ??
+                valueFromLayer(definition.key, config) ??
+                valueFromLayer(definition.key, defaults) ??
+                definition.defaultValue;
+    });
+    exports.optimizationOptionDefinitions
+        .filter((definition) => definition.defaultValue === undefined)
+        .forEach((definition) => {
+        resolved[definition.key] =
+            valueFromLayer(definition.key, cli) ??
+                valueFromLayer(definition.key, config) ??
+                valueFromLayer(definition.key, defaults) ??
+                false;
+    });
+    return resolved;
+}
+function isOptimizationOptionKey(value) {
+    return definitionsByKey.has(value);
+}

package/dist/progress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });