storm-lua-minify 0.3.0 → 0.9.0

package/dist/sourceMetadata.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMetadata = void 0;
+exports.isPreservedComment = isPreservedComment;
+const NONE = {
+    keep: false,
+    keepName: false,
+    exported: false,
+};
+function rangeOf(node) {
+    return node.range;
+}
+function statementChildren(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 collectStatements(body) {
+    const statements = [];
+    const visit = (block) => {
+        block.forEach((statement) => {
+            statements.push(statement);
+            statementChildren(statement).forEach(visit);
+        });
+    };
+    visit(body);
+    return statements.sort((a, b) => (rangeOf(a)?.[0] ?? 0) - (rangeOf(b)?.[0] ?? 0));
+}
+function hasBlankLine(text) {
+    return /\r?\n[\t ]*\r?\n/.test(text);
+}
+function parseAnnotations(comments) {
+    let keep = false;
+    let keepName = false;
+    let exported = false;
+    comments.forEach((comment) => {
+        const matches = comment.raw.matchAll(/--@storm\s+([^\r\n]*)/g);
+        for (const match of matches) {
+            const directive = match[1].trim();
+            if (directive === "keep") {
+                keep = true;
+            }
+            else if (directive === "keep-name") {
+                keepName = true;
+            }
+            else if (directive === "export") {
+                exported = true;
+                keep = true;
+                keepName = true;
+            }
+            else {
+                throw new Error(`Unknown storm annotation: ${directive || "(empty)"}`);
+            }
+        }
+    });
+    return { keep, keepName, exported };
+}
+function parseEmmyLua(comments) {
+    const directives = [];
+    comments.forEach((comment) => {
+        for (const match of comment.raw.matchAll(/---@([\w-]+)\s*([^\r\n]*)/g)) {
+            const directive = match[1];
+            const value = match[2].trim();
+            if (directive === "class") {
+                const parsed = /^([^\s:]+)(?:\s*:\s*([^\s]+))?/.exec(value);
+                if (parsed)
+                    directives.push({
+                        kind: "class",
+                        name: parsed[1],
+                        ...(parsed[2] ? { base: parsed[2] } : {}),
+                        comment,
+                    });
+            }
+            else if (directive === "field") {
+                const parsed = /^(?:(?:public|protected|private|package)\s+)?(?:\([^)]*\)\s*)?([^\s]+)\s+(.+)$/.exec(value);
+                if (parsed)
+                    directives.push({
+                        kind: "field",
+                        name: parsed[1],
+                        valueType: parsed[2].trim(),
+                        comment,
+                    });
+            }
+            else if (directive === "param") {
+                const parsed = /^(\S+)\s+(.+)$/.exec(value);
+                if (parsed)
+                    directives.push({
+                        kind: "param",
+                        name: parsed[1],
+                        valueType: parsed[2].trim(),
+                        comment,
+                    });
+            }
+            else if (directive === "return" || directive === "type") {
+                if (value)
+                    directives.push({ kind: directive, valueType: value, comment });
+            }
+            else if (directive === "alias") {
+                const parsed = /^(\S+)\s+(.+)$/.exec(value);
+                if (parsed)
+                    directives.push({
+                        kind: "alias",
+                        name: parsed[1],
+                        valueType: parsed[2].trim(),
+                        comment,
+                    });
+            }
+            else if (directive === "enum") {
+                const name = value.split(/\s+/)[0];
+                if (name)
+                    directives.push({ kind: "enum", name, comment });
+            }
+            else {
+                directives.push({ kind: "other", directive, value, comment });
+            }
+        }
+    });
+    return directives;
+}
+function isPreservedComment(comment) {
+    return comment.raw.includes("--#") || comment.raw.includes("[[#");
+}
+/** Source comments and annotations associated with statement nodes by range. */
+class SourceMetadata {
+    before = new WeakMap();
+    detachedBefore = new WeakMap();
+    trailing = new WeakMap();
+    annotations = new WeakMap();
+    emmyLua = new WeakMap();
+    afterModule = [];
+    statementOfIdentifier = new WeakMap();
+    constructor(chunk, sourceText) {
+        const statements = collectStatements(chunk.body);
+        statements.forEach((statement) => {
+            if (statement.type === "LocalStatement") {
+                statement.variables.forEach((identifier) => this.statementOfIdentifier.set(identifier, statement));
+            }
+            else if (statement.type === "FunctionDeclaration" &&
+                statement.identifier?.type === "Identifier") {
+                this.statementOfIdentifier.set(statement.identifier, statement);
+            }
+            else if (statement.type === "AssignmentStatement") {
+                statement.variables.forEach((variable) => {
+                    if (variable.type === "Identifier") {
+                        this.statementOfIdentifier.set(variable, statement);
+                    }
+                });
+            }
+        });
+        const comments = [...(chunk.comments ?? [])].sort((a, b) => (rangeOf(a)?.[0] ?? 0) - (rangeOf(b)?.[0] ?? 0));
+        let index = 0;
+        while (index < comments.length) {
+            const group = [comments[index++]];
+            while (index < comments.length) {
+                const previousEnd = rangeOf(group[group.length - 1])?.[1];
+                const nextStart = rangeOf(comments[index])?.[0];
+                if (previousEnd === undefined || nextStart === undefined)
+                    break;
+                const gap = sourceText.slice(previousEnd, nextStart);
+                if (/^\s*$/.test(gap) && !hasBlankLine(gap)) {
+                    group.push(comments[index++]);
+                }
+                else {
+                    break;
+                }
+            }
+            const first = group[0];
+            const last = group[group.length - 1];
+            const groupAnnotations = parseAnnotations(group);
+            const groupEmmyLua = parseEmmyLua(group);
+            const preceding = [...statements]
+                .reverse()
+                .find((statement) => (rangeOf(statement)?.[1] ?? Infinity) <=
+                (rangeOf(first)?.[0] ?? -1));
+            if (preceding?.loc?.end.line !== undefined &&
+                preceding.loc.end.line === first.loc?.start.line) {
+                this.trailing.set(preceding, [
+                    ...(this.trailing.get(preceding) ?? []),
+                    ...group,
+                ]);
+                continue;
+            }
+            const following = statements.find((statement) => (rangeOf(statement)?.[0] ?? -1) >= (rangeOf(last)?.[1] ?? Infinity));
+            if (following) {
+                const gap = sourceText.slice(rangeOf(last)?.[1] ?? 0, rangeOf(following)?.[0] ?? 0);
+                if (/^\s*$/.test(gap) && !hasBlankLine(gap)) {
+                    this.before.set(following, [
+                        ...(this.before.get(following) ?? []),
+                        ...group,
+                    ]);
+                    if (groupAnnotations.keep ||
+                        groupAnnotations.keepName ||
+                        groupAnnotations.exported) {
+                        this.annotations.set(following, groupAnnotations);
+                    }
+                    if (groupEmmyLua.length > 0)
+                        this.emmyLua.set(following, groupEmmyLua);
+                }
+                else {
+                    this.detachedBefore.set(following, [
+                        ...(this.detachedBefore.get(following) ?? []),
+                        ...group,
+                    ]);
+                }
+            }
+            else {
+                this.afterModule.push(...group);
+            }
+        }
+    }
+    annotationsOf(statement) {
+        return this.annotations.get(statement) ?? NONE;
+    }
+    annotationsOfIdentifier(identifier) {
+        const statement = this.statementOfIdentifier.get(identifier);
+        return statement ? this.annotationsOf(statement) : NONE;
+    }
+    emmyLuaOf(statement) {
+        return this.emmyLua.get(statement) ?? [];
+    }
+    emmyLuaOfIdentifier(identifier) {
+        const statement = this.statementOfIdentifier.get(identifier);
+        return statement ? this.emmyLuaOf(statement) : [];
+    }
+    beforeOf(statement) {
+        return [
+            ...(this.detachedBefore.get(statement) ?? []),
+            ...(this.before.get(statement) ?? []),
+        ];
+    }
+    trailingOf(statement) {
+        return this.trailing.get(statement) ?? [];
+    }
+    afterModuleComments() {
+        return this.afterModule;
+    }
+    transferStatements(sources, target) {
+        const before = sources.flatMap((statement) => [
+            ...(this.detachedBefore.get(statement) ?? []),
+            ...(this.before.get(statement) ?? []),
+        ]);
+        const trailing = sources.flatMap((statement) => this.trailing.get(statement) ?? []);
+        if (before.length)
+            this.before.set(target, before);
+        if (trailing.length)
+            this.trailing.set(target, trailing);
+        const annotations = sources.map((statement) => this.annotationsOf(statement));
+        const combined = {
+            keep: annotations.some((value) => value.keep),
+            keepName: annotations.some((value) => value.keepName),
+            exported: annotations.some((value) => value.exported),
+        };
+        if (combined.keep || combined.keepName || combined.exported) {
+            this.annotations.set(target, combined);
+        }
+        const emmyLua = sources.flatMap((statement) => this.emmyLuaOf(statement));
+        if (emmyLua.length > 0)
+            this.emmyLua.set(target, emmyLua);
+    }
+    /**
+     * 1つの文を複数文へ置換するとき、文境界に属する情報を外側の境界へ移す。
+     * leading/detachedは最初、trailingは最後へ置くことで、置換後もコメントの
+     * 前後関係を変えない。アノテーションは変換判断に使った後も、後続パスが
+     * 同じ保護指定を観測できるよう全置換文へ引き継ぐ。
+     */
+    replaceStatement(source, replacements) {
+        if (replacements.length === 0)
+            return;
+        const first = replacements[0];
+        const last = replacements[replacements.length - 1];
+        const detached = this.detachedBefore.get(source);
+        const before = this.before.get(source);
+        const trailing = this.trailing.get(source);
+        if (detached?.length)
+            this.detachedBefore.set(first, detached);
+        if (before?.length)
+            this.before.set(first, before);
+        if (trailing?.length)
+            this.trailing.set(last, trailing);
+        const annotations = this.annotations.get(source);
+        if (annotations) {
+            replacements.forEach((statement) => this.annotations.set(statement, annotations));
+        }
+        const emmyLua = this.emmyLua.get(source);
+        if (emmyLua) {
+            replacements.forEach((statement) => this.emmyLua.set(statement, emmyLua));
+        }
+    }
+    removeStatement(statement, nextStatement) {
+        const detached = this.detachedBefore.get(statement) ?? [];
+        if (detached.length === 0)
+            return;
+        if (nextStatement) {
+            this.detachedBefore.set(nextStatement, [
+                ...detached,
+                ...(this.detachedBefore.get(nextStatement) ?? []),
+            ]);
+        }
+        else {
+            this.afterModule.push(...detached);
+        }
+    }
+}
+exports.SourceMetadata = SourceMetadata;

package/dist/statementDataflow.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeStatementDataflow = analyzeStatementDataflow;
+const symbolLiveness_1 = require("./symbolLiveness");
+/** Shared CFG liveness and lexical statement-dependence analysis used by every scheduler rewrite. */
+function analyzeStatementDataflow(chunk, facts, valueFlow) {
+    if (facts.generation !== valueFlow.version) {
+        throw new Error("Statement dataflow requires one AST generation");
+    }
+    const controlFlow = valueFlow.controlFlow;
+    const symbolIds = new Map();
+    const globalIds = new Map();
+    const dependencies = [];
+    const dependenciesByFrom = new WeakMap();
+    const bodyOf = new WeakMap();
+    const indexOf = new WeakMap();
+    const symbolId = (symbol) => {
+        const existing = symbolIds.get(symbol);
+        if (existing !== undefined)
+            return existing;
+        const id = symbolIds.size;
+        symbolIds.set(symbol, id);
+        return id;
+    };
+    const globalId = (binding) => {
+        const existing = globalIds.get(binding);
+        if (existing !== undefined)
+            return existing;
+        const id = globalIds.size;
+        globalIds.set(binding, id);
+        return id;
+    };
+    const locationAccess = (location, owner) => {
+        switch (location.kind) {
+            case "local":
+            case "parameter":
+            case "upvalue":
+                return {
+                    family: "symbol",
+                    identity: `symbol:${String(symbolId(location.symbol))}`,
+                };
+            case "global":
+                return {
+                    family: "global",
+                    identity: `global:${String(globalId(location.binding))}`,
+                };
+            case "external":
+                return { family: "external", identity: "external:*" };
+            case "table": {
+                const point = controlFlow.pointOf(owner);
+                const allocation = point
+                    ? valueFlow.allocationOfBase(location.base, point)
+                    : undefined;
+                if (!allocation)
+                    return { family: "external", identity: "external:*" };
+                const tableIdentity = `allocation:${String(allocation.id)}`;
+                const tableKey = location.key.kind === "static" ? location.key.value : "*";
+                return {
+                    family: "table",
+                    identity: `${tableIdentity}:${tableKey}`,
+                    tableIdentity,
+                    tableKey,
+                };
+            }
+        }
+    };
+    const accessesOf = (operations, kind) => {
+        const result = [];
+        operations.forEach((operation) => {
+            if (kind === "read" &&
+                (operation.kind === "read" || operation.kind === "table-read"))
+                result.push(locationAccess(operation.location, operation.owner));
+            if (kind === "write" &&
+                (operation.kind === "write" ||
+                    operation.kind === "declare" ||
+                    operation.kind === "table-write"))
+                result.push(locationAccess(operation.location, operation.owner));
+        });
+        return deduplicateAccesses(result);
+    };
+    const summarize = (statement) => {
+        const operations = facts.operationsWithin(statement);
+        const expressionEffects = operations.flatMap((operation) => {
+            const origin = operation.origin;
+            return isExpression(origin) ? [facts.expressionFact(origin)] : [];
+        });
+        return {
+            reads: accessesOf(operations, "read"),
+            writes: accessesOf(operations, "write"),
+            hasCall: operations.some((operation) => operation.kind === "call"),
+            mayError: expressionEffects.some((fact) => fact?.effects.mayError.value === "may"),
+            mayMetamethod: expressionEffects.some((fact) => fact?.effects.mayInvokeMetamethod.value === "may"),
+            allocates: operations.some((operation) => operation.kind === "allocate"),
+            controlsFlow: isControlStatement(statement),
+            declares: operations.some((operation) => operation.kind === "declare"),
+        };
+    };
+    const liveness = (0, symbolLiveness_1.analyzeSymbolLiveness)(controlFlow, facts);
+    const analyzeBody = (body) => {
+        body.forEach((statement, index) => {
+            bodyOf.set(statement, body);
+            indexOf.set(statement, index);
+        });
+        const summaries = body.map(summarize);
+        for (let left = 0; left < body.length; left++) {
+            for (let right = left + 1; right < body.length; right++) {
+                dependencies.push(...edgesBetween(body[left], summaries[left], body[right], summaries[right]));
+            }
+        }
+        body.forEach((statement) => {
+            childBodies(statement).forEach(analyzeBody);
+        });
+    };
+    analyzeBody(chunk.body);
+    dependencies.forEach((edge) => {
+        let byTarget = dependenciesByFrom.get(edge.from);
+        if (!byTarget) {
+            byTarget = new WeakMap();
+            dependenciesByFrom.set(edge.from, byTarget);
+        }
+        const current = byTarget.get(edge.to) ?? [];
+        byTarget.set(edge.to, [...current, edge]);
+    });
+    return {
+        generation: facts.generation,
+        controlFlow,
+        symbolLiveness: liveness,
+        dependencies,
+        liveIn: (node) => liveness.liveIn(node),
+        liveOut: (node) => liveness.liveOut(node),
+        isLiveBefore: (statement, symbol) => {
+            const node = controlFlow.nodeOf(statement);
+            return !!node && liveness.liveIn(node).has(symbol);
+        },
+        isLiveAfter: (statement, symbol) => {
+            const node = controlFlow.nodeOf(statement);
+            return !!node && liveness.liveOut(node).has(symbol);
+        },
+        dependenciesBetween: (first, last) => dependenciesByFrom.get(first)?.get(last) ?? [],
+        canMoveBefore: (moving, target) => {
+            const body = bodyOf.get(moving);
+            if (!body || body !== bodyOf.get(target)) {
+                return { allowed: false, reason: "different-block" };
+            }
+            const movingIndex = indexOf.get(moving);
+            const targetIndex = indexOf.get(target);
+            if (movingIndex === undefined ||
+                targetIndex === undefined ||
+                targetIndex >= movingIndex)
+                return { allowed: false, reason: "different-block" };
+            const point = controlFlow.pointOf(moving);
+            if (!point ||
+                controlFlow.unknownEdges.some((edge) => edge.from.unit === point.unit))
+                return { allowed: false, reason: "unknown-edge" };
+            for (let index = targetIndex; index < movingIndex; index++) {
+                const obstacle = body[index];
+                const edge = dependencies.find((candidate) => candidate.from === obstacle && candidate.to === moving);
+                if (edge)
+                    return { allowed: false, reason: edge.kind };
+            }
+            return { allowed: true };
+        },
+    };
+}
+function edgesBetween(first, left, last, right) {
+    const edges = [];
+    const addHazard = (kind, a, b) => {
+        const locations = conflictingIdentities(a, b);
+        if (locations.length > 0)
+            edges.push({ from: first, to: last, kind, locations });
+    };
+    addHazard("read-after-write", left.writes, right.reads);
+    addHazard("write-after-read", left.reads, right.writes);
+    addHazard("write-after-write", left.writes, right.writes);
+    if (left.hasCall && right.hasCall)
+        edges.push({ from: first, to: last, kind: "call-order", locations: [] });
+    if (left.mayError && right.mayError)
+        edges.push({ from: first, to: last, kind: "error-order", locations: [] });
+    if (left.mayMetamethod && right.mayMetamethod)
+        edges.push({
+            from: first,
+            to: last,
+            kind: "metamethod-order",
+            locations: [],
+        });
+    if (left.allocates && right.allocates)
+        edges.push({
+            from: first,
+            to: last,
+            kind: "allocation-order",
+            locations: [],
+        });
+    if (left.controlsFlow || right.controlsFlow)
+        edges.push({ from: first, to: last, kind: "control-order", locations: [] });
+    if (left.declares || right.declares)
+        edges.push({ from: first, to: last, kind: "scope-order", locations: [] });
+    return edges;
+}
+function conflictingIdentities(left, right) {
+    const conflicts = new Set();
+    left.forEach((a) => {
+        right.forEach((b) => {
+            if (accessesConflict(a, b))
+                conflicts.add(a.identity === "external:*" ? b.identity : a.identity);
+        });
+    });
+    return [...conflicts].sort();
+}
+function accessesConflict(left, right) {
+    if (left.family === "external" || right.family === "external")
+        return true;
+    if (left.family !== right.family)
+        return false;
+    if (left.family !== "table")
+        return left.identity === right.identity;
+    return (left.tableIdentity === right.tableIdentity &&
+        (left.tableKey === "*" ||
+            right.tableKey === "*" ||
+            left.tableKey === right.tableKey));
+}
+function deduplicateAccesses(accesses) {
+    const seen = new Set();
+    return accesses.filter((access) => {
+        if (seen.has(access.identity))
+            return false;
+        seen.add(access.identity);
+        return true;
+    });
+}
+function isExpression(node) {
+    return (node.type.endsWith("Expression") ||
+        node.type.endsWith("Literal") ||
+        node.type === "Identifier");
+}
+function isControlStatement(statement) {
+    return (statement.type === "IfStatement" ||
+        statement.type === "WhileStatement" ||
+        statement.type === "RepeatStatement" ||
+        statement.type === "ForNumericStatement" ||
+        statement.type === "ForGenericStatement" ||
+        statement.type === "BreakStatement" ||
+        statement.type === "ReturnStatement" ||
+        statement.type === "GotoStatement" ||
+        statement.type === "LabelStatement");
+}
+function childBodies(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        default:
+            return [];
+    }
+}