storm-lua-minify 0.3.0 → 0.9.0

package/dist/removeUnused.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUnusedLocals = removeUnusedLocals;
+function rangeOf(node) {
+    return node.range;
+}
+function nestedBodies(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "FunctionDeclaration":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        default:
+            return [];
+    }
+}
+function isStatementCall(expression) {
+    return (expression.type === "CallExpression" ||
+        expression.type === "TableCallExpression" ||
+        expression.type === "StringCallExpression");
+}
+function callStatement(expression) {
+    return {
+        type: "CallStatement",
+        expression,
+        loc: expression.loc,
+        range: rangeOf(expression),
+    };
+}
+function hasExternalReference(statement, references) {
+    const range = rangeOf(statement);
+    if (!range)
+        return references.length > 0;
+    return references.some((reference) => {
+        const position = rangeOf(reference)?.[0];
+        return (position === undefined || position < range[0] || position >= range[1]);
+    });
+}
+function removeFromBlock(body, resolved, metadata, facts, onRemoveLocalFunction, options = { removeLocals: true, removeFunctions: true }) {
+    let changed = false;
+    body.forEach((statement) => {
+        nestedBodies(statement).forEach((nested) => {
+            changed =
+                removeFromBlock(nested, resolved, metadata, facts, onRemoveLocalFunction, options) || changed;
+        });
+    });
+    const replacements = new Map();
+    body.forEach((statement) => {
+        if (metadata.annotationsOf(statement).keep)
+            return;
+        if (options.removeFunctions &&
+            statement.type === "FunctionDeclaration" &&
+            statement.isLocal &&
+            statement.identifier?.type === "Identifier") {
+            const symbol = resolved.symbolOf(statement.identifier);
+            if (symbol && !hasExternalReference(statement, symbol.references)) {
+                onRemoveLocalFunction?.(statement);
+                changed = true;
+                replacements.set(statement, []);
+                return;
+            }
+        }
+        if (!options.removeLocals || statement.type !== "LocalStatement")
+            return;
+        const unused = statement.variables.map((variable) => {
+            const symbol = resolved.symbolOf(variable);
+            return Boolean(symbol && symbol.references.length === 0);
+        });
+        if (!unused.some(Boolean))
+            return;
+        if (unused.every(Boolean)) {
+            if (statement.init.every((expression) => facts.discardabilityOf(expression).discardable ||
+                isStatementCall(expression))) {
+                const calls = statement.init.filter(isStatementCall).map(callStatement);
+                changed = true;
+                replacements.set(statement, calls);
+            }
+            return;
+        }
+        let variables = [...statement.variables];
+        let init = [...statement.init];
+        let unusedAfterPairRemoval = [...unused];
+        // 初期値なしなら全変数の値はnilで固定され、位置対応を維持する必要がない。
+        if (init.length === 0) {
+            variables = variables.filter((_, index) => !unused[index]);
+            unusedAfterPairRemoval = unused.filter((value) => !value);
+        }
+        // 要素数が一致するときだけ、変数とRHSの対応を崩さず安全なペアを抜ける。
+        if (init.length > 0 && variables.length === init.length) {
+            const retainedIndexes = variables
+                .map((_, index) => index)
+                .filter((index) => !(unused[index] && facts.discardabilityOf(init[index]).discardable));
+            variables = retainedIndexes.map((index) => variables[index]);
+            init = retainedIndexes.map((index) => init[index]);
+            unusedAfterPairRemoval = retainedIndexes.map((index) => unused[index]);
+        }
+        // 末尾の未使用名は、対応RHSを余剰式として評価させたまま名前だけ除ける。
+        let retainedVariableCount = variables.length;
+        while (retainedVariableCount > 0 &&
+            unusedAfterPairRemoval[retainedVariableCount - 1]) {
+            retainedVariableCount--;
+        }
+        variables = variables.slice(0, retainedVariableCount);
+        if (variables.length === statement.variables.length)
+            return;
+        changed = true;
+        const replacement = {
+            ...statement,
+            variables,
+            init,
+        };
+        replacements.set(statement, [replacement]);
+    });
+    if (replacements.size > 0) {
+        const nextBody = [];
+        body.forEach((statement, index) => {
+            const replacement = replacements.get(statement);
+            if (!replacement) {
+                nextBody.push(statement);
+                return;
+            }
+            if (replacement.length > 0) {
+                metadata.replaceStatement(statement, replacement);
+                nextBody.push(...replacement);
+                return;
+            }
+            const next = body.slice(index + 1).find((candidate) => {
+                const candidateReplacement = replacements.get(candidate);
+                return !candidateReplacement || candidateReplacement.length > 0;
+            });
+            const nextReplacement = next ? replacements.get(next) : undefined;
+            metadata.removeStatement(statement, nextReplacement?.[0] ?? next);
+        });
+        body.splice(0, body.length, ...nextBody);
+    }
+    return changed;
+}
+function removeUnusedLocals(chunk, resolved, metadata, facts, onRemoveLocalFunction, options) {
+    return removeFromBlock(chunk.body, resolved, metadata, facts, onRemoveLocalFunction, options);
+}

package/dist/renamer.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAvailable = isAvailable;
 exports.generateCandidate = generateCandidate;
 exports.assignRenames = assignRenames;
+const resolver_1 = require("./resolver");
 const ast2lua_1 = require("./ast2lua");
+const controlFlow_1 = require("./controlFlow");
+const optimizerFacts_1 = require("./optimizerFacts");
+const symbolLiveness_1 = require("./symbolLiveness");
 function isAvailable(id, reserved) {
     return id !== "self" && !(0, ast2lua_1.isKeyword)(id) && !reserved.has(id);
 }
@@ -21,62 +25,33 @@ function generateCandidate(counter) {
     }
     return id;
 }
-/**
- * スコープ木のDFSでシンボルごとにスロット番号を割り当てる。
- * `active`は祖先スコープ（自分を含む）で既に使われているスロットの集合。
- * 兄弟スコープには同じ`active`のコピーが渡されるため、互いの割当は影響しない。
- */
-function assignSlots(scope, active) {
-    const slotOf = new Map();
-    const used = new Set(active);
-    scope.symbols.forEach((symbol) => {
-        let slot = 0;
-        while (used.has(slot)) {
-            slot++;
-        }
-        slotOf.set(symbol, slot);
-        used.add(slot);
-    });
-    scope.children.forEach((child) => {
-        assignSlots(child, used).forEach((slot, symbol) => {
-            slotOf.set(symbol, slot);
-        });
-    });
-    return slotOf;
-}
-function assignRenames(resolveResult, reserved, 
+function assignRenames(chunk, resolveResult, reserved, 
 // #8a: プログラム全体を横断して決定されたグローバル識別子の短縮名。
 // 全モジュールに対して同じマップを渡すことで、モジュールをまたいで
 // 共有される1つのランタイム束縛に一貫した短縮名を割り当てられる。
-globalRenames) {
-    const slotOf = assignSlots(resolveResult.chunkScope, new Set());
-    // スロットの通算参照回数（宣言自体も1回として数える）を集計する。
-    const weightOfSlot = new Map();
-    resolveResult.symbols.forEach((symbol) => {
-        const slot = slotOf.get(symbol);
-        if (slot === undefined) {
-            return;
-        }
-        const weight = symbol.references.length + 1;
-        weightOfSlot.set(slot, (weightOfSlot.get(slot) ?? 0) + weight);
-    });
-    const orderedSlots = [...weightOfSlot.keys()].sort((a, b) => (weightOfSlot.get(b) ?? 0) - (weightOfSlot.get(a) ?? 0));
-    const nameOfSlot = new Map();
-    let counter = 0;
-    orderedSlots.forEach((slot) => {
-        let candidate;
-        do {
-            candidate = generateCandidate(counter++);
-        } while (!isAvailable(candidate, reserved));
-        nameOfSlot.set(slot, candidate);
-    });
-    const nameOfSymbol = new Map();
-    slotOf.forEach((slot, symbol) => {
-        const name = nameOfSlot.get(slot);
-        if (name !== undefined) {
-            nameOfSymbol.set(symbol, name);
-        }
-    });
+globalRenames, keepNames = new Set(), options = {}) {
+    const unavailableNames = new Set(reserved);
+    keepNames.forEach((symbol) => unavailableNames.add(symbol.name));
+    const variables = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind !== "label" &&
+            !symbol.implicit &&
+            !keepNames.has(symbol));
+    const variableGraph = buildVariableInterference(chunk, resolveResult, variables, options.allowLocalNameReuse === true, options.analysis);
+    const variableColors = colorGraph(variableGraph);
+    const variableNames = assignColorNames(variableColors, unavailableNames);
+    // Labels have a separate Lua namespace. Color them independently so a label
+    // and a local may share a short spelling, while usedNames still reserves the
+    // spelling against labels from subsequently spliced modules.
+    const labels = options.renameLocals === false
+        ? []
+        : resolveResult.symbols.filter((symbol) => symbol.kind === "label" &&
+            symbol.name !== "self" &&
+            !keepNames.has(symbol));
+    const labelNames = assignColorNames(colorGraph(buildLexicalGraph(labels, false)), unavailableNames);
+    const nameOfSymbol = new Map([...variableNames, ...labelNames]);
+    validateBindings(chunk, resolveResult, nameOfSymbol, globalRenames);
+    const usedNames = new Set(nameOfSymbol.values());
     return {
         nameOf: (identifier) => {
             // メソッド定義の暗黙のselfパラメータは慣習的な名前のため常に維持する
@@ -96,6 +71,200 @@ globalRenames) {
             }
             return undefined;
         },
-        usedNames: new Set(nameOfSlot.values()),
+        usedNames,
     };
 }
+function buildVariableInterference(chunk, resolved, symbols, allowLocalNameReuse, analysis) {
+    const graph = mutableGraph(symbols);
+    const facts = analysis?.facts ?? (0, optimizerFacts_1.analyzeOptimizerFacts)(chunk, resolved);
+    const liveness = analysis?.liveness ??
+        (0, symbolLiveness_1.analyzeSymbolLiveness)((0, controlFlow_1.analyzeControlFlow)(chunk, resolved), facts);
+    if (facts.generation !== liveness.controlFlow.version)
+        throw new Error("Identifier coloring requires one AST generation");
+    liveness.controlFlow.nodes.forEach((node) => {
+        addClique(graph, liveness.liveIn(node));
+        addClique(graph, liveness.liveOut(node));
+        liveness.defs(node).forEach((definition) => {
+            liveness.liveOut(node).forEach((live) => {
+                addEdge(graph, definition, live);
+            });
+        });
+    });
+    // Parameters, generic-for variables, and multi-local declarations bind as a
+    // group. Giving two members one spelling would make only the last binding
+    // addressable after reparsing even if one member happens to be unused.
+    const declarationsByOwner = new Map();
+    symbols.forEach((symbol) => {
+        const declaration = facts
+            .operationsOfSymbol(symbol)
+            .find((operation) => operation.kind === "declare" &&
+            operation.origin === symbol.declaration);
+        if (!declaration)
+            return;
+        const group = declarationsByOwner.get(declaration.owner) ?? [];
+        group.push(symbol);
+        declarationsByOwner.set(declaration.owner, group);
+    });
+    declarationsByOwner.forEach((group) => {
+        addClique(graph, group);
+    });
+    // A captured binding can be shadowed inside the closure by any same-scope
+    // declaration whose emitted spelling matches it (notably `local function`).
+    // Extending this lexical interference across the whole declaring scope is
+    // conservative, deterministic, and leaves ordinary non-captured locals free
+    // to reuse names according to liveness.
+    symbols.forEach((symbol) => {
+        const captured = facts
+            .operationsOfSymbol(symbol)
+            .some((operation) => "location" in operation && operation.location.kind === "upvalue");
+        if (!captured)
+            return;
+        symbols.forEach((other) => {
+            if (other.scope === symbol.scope)
+                addEdge(graph, symbol, other);
+        });
+    });
+    addLexicalEdges(graph, symbols, allowLocalNameReuse);
+    return graph;
+}
+function buildLexicalGraph(symbols, allowSameScopeReuse) {
+    const graph = mutableGraph(symbols);
+    addLexicalEdges(graph, symbols, allowSameScopeReuse);
+    return graph;
+}
+function mutableGraph(symbols) {
+    return new Map(symbols.map((symbol) => [symbol, new Set()]));
+}
+function addLexicalEdges(graph, symbols, allowSameScopeReuse) {
+    for (let left = 0; left < symbols.length; left++) {
+        for (let right = left + 1; right < symbols.length; right++) {
+            const first = symbols[left];
+            const last = symbols[right];
+            if (isAncestor(first.scope, last.scope) ||
+                isAncestor(last.scope, first.scope) ||
+                (!allowSameScopeReuse && first.scope === last.scope))
+                addEdge(graph, first, last);
+        }
+    }
+}
+function isAncestor(ancestor, descendant) {
+    if (ancestor === descendant)
+        return false;
+    for (let current = descendant.parent; current; current = current.parent)
+        if (current === ancestor)
+            return true;
+    return false;
+}
+function addClique(graph, symbols) {
+    const present = [...symbols].filter((symbol) => graph.has(symbol));
+    for (let left = 0; left < present.length; left++)
+        for (let right = left + 1; right < present.length; right++)
+            addEdge(graph, present[left], present[right]);
+}
+function addEdge(graph, first, last) {
+    if (first === last || !graph.has(first) || !graph.has(last))
+        return;
+    graph.get(first)?.add(last);
+    graph.get(last)?.add(first);
+}
+/** Deterministic weighted DSATUR coloring. */
+function colorGraph(graph) {
+    const colors = new Map();
+    while (colors.size < graph.size) {
+        const remaining = [...graph.keys()].filter((symbol) => !colors.has(symbol));
+        remaining.sort((left, right) => {
+            const saturationDifference = saturation(graph, colors, right) - saturation(graph, colors, left);
+            if (saturationDifference !== 0)
+                return saturationDifference;
+            const weightDifference = weightOf(right) - weightOf(left);
+            if (weightDifference !== 0)
+                return weightDifference;
+            const degreeDifference = (graph.get(right)?.size ?? 0) - (graph.get(left)?.size ?? 0);
+            return degreeDifference !== 0 ? degreeDifference : left.id - right.id;
+        });
+        const symbol = remaining[0];
+        const unavailable = new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
+            const color = colors.get(neighbor);
+            return color === undefined ? [] : [color];
+        }));
+        let color = 0;
+        while (unavailable.has(color))
+            color++;
+        colors.set(symbol, color);
+    }
+    return colors;
+}
+function saturation(graph, colors, symbol) {
+    return new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
+        const color = colors.get(neighbor);
+        return color === undefined ? [] : [color];
+    })).size;
+}
+function weightOf(symbol) {
+    return symbol.references.length + 1;
+}
+function assignColorNames(colors, reserved) {
+    const unavailable = new Set(reserved);
+    const weightByColor = new Map();
+    const firstSymbolByColor = new Map();
+    colors.forEach((color, symbol) => {
+        weightByColor.set(color, (weightByColor.get(color) ?? 0) + weightOf(symbol));
+        firstSymbolByColor.set(color, Math.min(firstSymbolByColor.get(color) ?? symbol.id, symbol.id));
+    });
+    const orderedColors = [...weightByColor.keys()].sort((left, right) => (weightByColor.get(right) ?? 0) - (weightByColor.get(left) ?? 0) ||
+        (firstSymbolByColor.get(left) ?? 0) -
+            (firstSymbolByColor.get(right) ?? 0));
+    const nameByColor = new Map();
+    let counter = 0;
+    orderedColors.forEach((color) => {
+        let candidate;
+        do
+            candidate = generateCandidate(counter++);
+        while (!isAvailable(candidate, unavailable));
+        unavailable.add(candidate);
+        nameByColor.set(color, candidate);
+    });
+    // Every candidate is an identifier token and keywords are excluded, so the
+    // separator cost around each occurrence is invariant across candidates.
+    // Occurrence count therefore gives the exact candidate-dependent byte cost.
+    const result = new Map();
+    colors.forEach((color, symbol) => {
+        const name = nameByColor.get(color);
+        if (name === undefined)
+            throw new Error("Colored symbol has no name");
+        result.set(symbol, name);
+    });
+    return result;
+}
+function validateBindings(chunk, original, names, globalRenames) {
+    const recolored = (0, resolver_1.resolveScopes)(chunk, {
+        identifierName: (identifier) => {
+            const symbol = original.symbolOf(identifier);
+            if (symbol)
+                return names.get(symbol) ?? identifier.name;
+            return original.isGlobalReference(identifier)
+                ? (globalRenames?.get(identifier.name) ?? identifier.name)
+                : identifier.name;
+        },
+    });
+    original.symbols.forEach((symbol) => {
+        if (symbol.implicit) {
+            symbol.references.forEach((identifier) => {
+                const rebound = recolored.symbolOf(identifier);
+                if (!rebound?.implicit || rebound.name !== symbol.name)
+                    throw new Error(`Identifier coloring changed implicit binding for symbol ${String(symbol.id)}`);
+            });
+            return;
+        }
+        [symbol.declaration, ...symbol.references].forEach((identifier) => {
+            if (recolored.symbolOf(identifier)?.declaration !== symbol.declaration)
+                throw new Error(`Identifier coloring changed binding for symbol ${String(symbol.id)}`);
+        });
+    });
+    original.globals.forEach((binding) => {
+        binding.references.forEach((identifier) => {
+            if (!recolored.isGlobalReference(identifier))
+                throw new Error(`Identifier coloring captured global ${binding.name}`);
+        });
+    });
+}

package/dist/resolver.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveScopes = resolveScopes;
-function resolveScopes(chunk) {
+function resolveScopes(chunk, options = {}) {
     let nextSymbolId = 0;
     const allSymbols = [];
     const globals = new Map();
     const identifierSymbols = new WeakMap();
     const globalReferenceNodes = new WeakSet();
+    const functionScopes = new WeakMap();
+    const identifierName = options.identifierName ??
+        ((identifier) => identifier.name);
     function createScope(kind, parent) {
         const scope = {
             kind,
@@ -19,33 +22,36 @@ function resolveScopes(chunk) {
         parent?.children.push(scope);
         return scope;
     }
-    function declare(scope, node, kind) {
+    function declare(scope, node, kind, implicit = false) {
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind,
             scope,
             declaration: node,
             references: [],
+            ...(implicit ? { implicit: true } : {}),
         };
         // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
         scope.symbols.push(symbol);
-        scope.bindings.set(node.name, symbol);
+        scope.bindings.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
     }
     function declareLabel(scope, node) {
+        const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
-            name: node.name,
+            name,
             kind: "label",
             scope,
             declaration: node,
             references: [],
         };
         scope.symbols.push(symbol);
-        scope.labels.set(node.name, symbol);
+        scope.labels.set(name, symbol);
         allSymbols.push(symbol);
         identifierSymbols.set(node, symbol);
         return symbol;
@@ -69,16 +75,17 @@ function resolveScopes(chunk) {
         return undefined;
     }
     function reference(scope, node, isWrite = false) {
-        const symbol = lookupBinding(scope, node.name);
+        const name = identifierName(node);
+        const symbol = lookupBinding(scope, name);
         if (symbol) {
             symbol.references.push(node);
             identifierSymbols.set(node, symbol);
             return;
         }
-        let binding = globals.get(node.name);
+        let binding = globals.get(name);
         if (!binding) {
-            binding = { name: node.name, references: [], writes: [] };
-            globals.set(node.name, binding);
+            binding = { name, references: [], writes: [] };
+            globals.set(name, binding);
         }
         binding.references.push(node);
         if (isWrite) {
@@ -188,7 +195,7 @@ function resolveScopes(chunk) {
                 // hoistLabelsで宣言済みのため、ここでは何もしない
                 return;
             case "GotoStatement": {
-                const symbol = lookupLabel(scope, statement.label.name);
+                const symbol = lookupLabel(scope, identifierName(statement.label));
                 if (symbol) {
                     symbol.references.push(statement.label);
                     identifierSymbols.set(statement.label, symbol);
@@ -218,6 +225,14 @@ function resolveScopes(chunk) {
             }
         }
         const inner = createScope("function", scope);
+        functionScopes.set(fn, inner);
+        if (fn.identifier?.type === "MemberExpression" &&
+            fn.identifier.indexer === ":") {
+            // `function object:method(...)` declares an implicit first parameter. It has no
+            // declaration token in the AST, but it must still own every `self` reference so
+            // global analysis, aliases, summaries, and binding validation share Lua's binding.
+            declare(inner, { type: "Identifier", name: "self" }, "param", true);
+        }
         fn.parameters.forEach((parameter) => {
             if (parameter.type === "Identifier") {
                 declare(inner, parameter, "param");
@@ -268,6 +283,7 @@ function resolveScopes(chunk) {
                 return;
             case "FunctionDeclaration": {
                 const inner = createScope("function", scope);
+                functionScopes.set(expr, inner);
                 expr.parameters.forEach((parameter) => {
                     if (parameter.type === "Identifier") {
                         declare(inner, parameter, "param");
@@ -305,5 +321,6 @@ function resolveScopes(chunk) {
         globals,
         symbolOf: (identifier) => identifierSymbols.get(identifier),
         isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
+        scopeOfFunction: (fn) => functionScopes.get(fn),
     };
 }

package/dist/runtimeEnvironment.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeEnvironmentOf = runtimeEnvironmentOf;
+exports.checkParallelValueCount = checkParallelValueCount;
+exports.checkParallelEvaluation = checkParallelEvaluation;
+exports.analyzeLocalResourceUsage = analyzeLocalResourceUsage;
+const COMMON_RESOURCES = {
+    maxActiveLocalsPerFunction: 200,
+    maxRegistersPerFunction: 255,
+    // compilerの一時register推定が未完成でも、local/register上限間に余裕を残す。
+    conservativeParallelValueLimit: 50,
+};
+function runtimeEnvironmentOf(profile) {
+    if (profile === "stormworks") {
+        return {
+            profile,
+            semantics: {
+                mutableMetatables: false,
+                debugLocalIntrospection: false,
+            },
+            resources: COMMON_RESOURCES,
+        };
+    }
+    return {
+        profile,
+        semantics: {
+            mutableMetatables: true,
+            debugLocalIntrospection: true,
+        },
+        resources: COMMON_RESOURCES,
+    };
+}
+function checkParallelValueCount(environment, count) {
+    return checkParallelEvaluation(environment, {
+        activeLocalsBefore: 0,
+        parallelValueCount: count,
+    });
+}
+function checkParallelEvaluation(environment, request) {
+    const limit = environment.resources.conservativeParallelValueLimit;
+    const localHeadroom = Math.max(0, environment.resources.maxActiveLocalsPerFunction -
+        request.activeLocalsBefore);
+    const registerHeadroom = Math.max(0, environment.resources.maxRegistersPerFunction - request.activeLocalsBefore);
+    const allowedCount = Math.min(limit, localHeadroom, registerHeadroom);
+    const estimatedPeakRegisters = request.activeLocalsBefore + request.parallelValueCount;
+    if (request.parallelValueCount <= allowedCount) {
+        return {
+            allowed: true,
+            confidence: "conservative-policy",
+            limit: allowedCount,
+            estimatedPeakRegisters,
+        };
+    }
+    const reason = localHeadroom < request.parallelValueCount
+        ? "local-limit"
+        : registerHeadroom < request.parallelValueCount
+            ? "register-limit"
+            : "parallel-value-limit";
+    return {
+        allowed: false,
+        reason,
+        limit: allowedCount,
+        estimatedPeakRegisters,
+    };
+}
+/** 各function/blockの字句的local生存数を、文の直前位置で数える。 */
+function analyzeLocalResourceUsage(chunk) {
+    const activeBefore = new WeakMap();
+    const visitBlock = (body, entryActive) => {
+        let active = entryActive;
+        body.forEach((statement) => {
+            activeBefore.set(statement, active);
+            switch (statement.type) {
+                case "LocalStatement":
+                    active += statement.variables.length;
+                    break;
+                case "FunctionDeclaration":
+                    visitBlock(statement.body, statement.parameters.length);
+                    if (statement.isLocal)
+                        active++;
+                    break;
+                case "DoStatement":
+                case "WhileStatement":
+                    visitBlock(statement.body, active);
+                    break;
+                case "RepeatStatement":
+                    visitBlock(statement.body, active);
+                    break;
+                case "IfStatement":
+                    statement.clauses.forEach((clause) => {
+                        visitBlock(clause.body, active);
+                    });
+                    break;
+                case "ForNumericStatement":
+                    visitBlock(statement.body, active + 1);
+                    break;
+                case "ForGenericStatement":
+                    visitBlock(statement.body, active + statement.variables.length);
+                    break;
+            }
+        });
+    };
+    visitBlock(chunk.body, 0);
+    return { activeLocalsBefore: (statement) => activeBefore.get(statement) };
+}