semantifold 0.3.0 → 0.5.0

package/build/src/semantic/lifetime.js

@@ -0,0 +1,527 @@
+// @ts-check
+/** @typedef {(code: string, detail: string, location: import("./types.js").SourceLocation) => never} LifetimeFail */
+/** @typedef {{kind: "open", originId: string, origin: import("./types.js").SourceLocation} | {kind: "moved", originId: string, origin: import("./types.js").SourceLocation, destination: string} | {kind: "terminal", originId: string, origin: import("./types.js").SourceLocation, closeSiteId: string | import("./types.js").SourceLocation}} OwnerState */
+/** @typedef {{kind: "normal" | "return" | "raise" | "break" | "continue", state: Map<string, OwnerState>, location?: import("./types.js").SourceLocation, errorId?: string}} LifetimeExit */
+/**
+ * Performs path-sensitive structured lifetime validation for Task 034 owned values.
+ * @param {import("./types.js").SemanticModule} module - Fully type-resolved module.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @param {LifetimeFail} fail - Located failure.
+ * @returns {void}
+ */
+export function validateResourceLifetimes(module, errorEffects, fail) {
+    if (!(module.capabilities ?? []).some(({ resources }) => resources.length > 0) && !moduleContainsOwnedType(module))
+        return;
+    for (const declaration of module.classes ?? []) {
+        analyzeOwner(declaration.constructor.parameters, declaration.constructor.body, fail, undefined, errorEffects);
+        for (const method of declaration.methods)
+            analyzeOwner(method.parameters, method.body, fail, declaration.ownership?.kind == "ownedResource" ? declaration.ownership.fieldId : undefined, errorEffects);
+    }
+    for (const declaration of module.functions)
+        analyzeOwner(declaration.parameters, declaration.body, fail, undefined, errorEffects);
+    analyzeOwner([], module.entryPoint.body, fail, undefined, errorEffects);
+}
+/**
+ * Analyzes one function, constructor, method, or entry-point owner.
+ * @param {import("./types.js").Parameter[]} parameters - Owned parameters.
+ * @param {import("./types.js").Block} body - Structured body.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {string | undefined} borrowedFieldId - Owned receiver field, when present.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {void}
+ */
+function analyzeOwner(parameters, body, fail, borrowedFieldId, errorEffects) {
+    /** @type {Map<string, OwnerState>} */
+    const initial = new Map();
+    const obligations = new Set(parameters.filter(({ type }) => isOwned(type)).map(({ name }) => name));
+    for (const parameter of parameters) {
+        if (isOwned(parameter.type))
+            initial.set(parameter.name, openState(`parameter:${parameter.name}`, parameter.location));
+    }
+    if (borrowedFieldId)
+        initial.set(`this.${borrowedFieldId}`, openState(`receiver:${borrowedFieldId}`, body.location));
+    const exits = analyzeBlock(body, [{ kind: "normal", state: initial }], fail, errorEffects);
+    for (const exit of exits)
+        checkLeaks(exit.state, obligations, exit.location ?? body.location, fail);
+}
+/**
+ * Evaluates one lexical block while retaining every abrupt exit separately.
+ * @param {import("./types.js").Block} block - Structured block.
+ * @param {LifetimeExit[]} incoming - Incoming control-flow states.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function analyzeBlock(block, incoming, fail, errorEffects) {
+    let active = incoming.filter(({ kind }) => kind == "normal");
+    const departed = incoming.filter(({ kind }) => kind != "normal");
+    /** @type {Set<string>} */
+    const locals = new Set();
+    for (const statement of block.statements) {
+        if (active.length == 0)
+            break;
+        const next = [];
+        for (const flow of active)
+            next.push(...analyzeStatement(statement, flow.state, fail, locals, errorEffects));
+        departed.push(...next.filter(({ kind }) => kind != "normal"));
+        active = mergeEquivalentNormals(next.filter(({ kind }) => kind == "normal"), statement.location, fail);
+    }
+    const exits = [...departed, ...active.map((flow) => ({ ...flow, location: flow.location ?? block.location }))];
+    for (const exit of exits) {
+        checkLeaks(exit.state, locals, exit.location ?? block.location, fail);
+        for (const name of locals)
+            exit.state.delete(name);
+    }
+    return exits;
+}
+/**
+ * Evaluates one statement from one normal state.
+ * @param {import("./types.js").Statement} statement - Statement.
+ * @param {Map<string, OwnerState>} state - Incoming ownership state.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {Set<string>} locals - Locals introduced in the current block.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function analyzeStatement(statement, state, fail, locals, errorEffects) {
+    if (statement.kind == "LocalDeclaration") {
+        const flows = evaluateExpression(statement.initializer, cloneState(state), fail, errorEffects);
+        if (isOwned(statement.type)) {
+            locals.add(statement.name);
+            for (const flow of flows) {
+                if (flow.kind != "normal")
+                    continue;
+                const origin = statement.initializer.kind == "OwnedMoveExpression"
+                    ? flow.state.get(statement.initializer.expression.name)?.origin ?? statement.initializer.location
+                    : statement.initializer.location;
+                flow.state.set(statement.name, openState(`local:${statement.name}`, origin));
+            }
+        }
+        return flows.map((flow) => ({ ...flow, location: statement.location }));
+    }
+    if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
+        return evaluateExpression(statement.expression, cloneState(state), fail, errorEffects)
+            .map((flow) => ({ ...flow, location: statement.location }));
+    }
+    if (statement.kind == "AssignmentStatement" || statement.kind == "PrivateFieldWriteStatement") {
+        return evaluateExpression(statement.expression, cloneState(state), fail, errorEffects)
+            .map((flow) => ({ ...flow, location: statement.location }));
+    }
+    if (statement.kind == "ReturnStatement") {
+        const flows = statement.expression ? evaluateExpression(statement.expression, cloneState(state), fail, errorEffects) :
+            /** @type {LifetimeExit[]} */ ([{ kind: "normal", state: cloneState(state) }]);
+        return flows.map((flow) => flow.kind == "normal"
+            ? { kind: "return", location: statement.location, state: flow.state }
+            : { ...flow, location: statement.location });
+    }
+    if (statement.kind == "RaiseStatement") {
+        const flows = evaluateExpression(statement.error.message, cloneState(state), fail, errorEffects);
+        return flows.map((flow) => flow.kind == "normal"
+            ? { errorId: statement.error.error.declarationId, kind: "raise", location: statement.location, state: flow.state }
+            : { ...flow, location: statement.location });
+    }
+    if (statement.kind == "IfStatement") {
+        const conditions = evaluateExpression(statement.condition, cloneState(state), fail, errorEffects);
+        /** @type {LifetimeExit[]} */
+        const result = conditions.filter(({ kind }) => kind != "normal");
+        for (const condition of conditions.filter(({ kind }) => kind == "normal")) {
+            result.push(...analyzeBlock(statement.consequent, [{ kind: "normal", state: cloneState(condition.state) }], fail, errorEffects));
+            const alternate = statement.alternate
+                ? analyzeBlock(statement.alternate, [{ kind: "normal", state: cloneState(condition.state) }], fail, errorEffects)
+                : /** @type {LifetimeExit[]} */ ([{ kind: "normal", location: statement.location, state: cloneState(condition.state) }]);
+            result.push(...alternate);
+        }
+        return mergeEquivalentNormals(result, statement.location, fail);
+    }
+    if (statement.kind == "TryStatement") {
+        const bodyExits = analyzeBlock(statement.body, [{ kind: "normal", state: cloneState(state) }], fail, errorEffects);
+        /** @type {LifetimeExit[]} */
+        const result = bodyExits.filter((flow) => flow.kind != "raise" || flow.errorId != statement.catchType.declarationId);
+        for (const caught of bodyExits.filter((flow) => flow.kind == "raise" && flow.errorId == statement.catchType.declarationId)) {
+            result.push(...analyzeBlock(statement.catchBody, [{ kind: "normal", state: cloneState(caught.state) }], fail, errorEffects));
+        }
+        return mergeEquivalentNormals(result, statement.location, fail);
+    }
+    if (statement.kind == "WhileStatement") {
+        const conditions = evaluateExpression(statement.condition, cloneState(state), fail, errorEffects);
+        /** @type {LifetimeExit[]} */
+        const result = conditions.filter(({ kind }) => kind != "normal");
+        for (const condition of conditions.filter(({ kind }) => kind == "normal")) {
+            const bodyExits = analyzeBlock(statement.body, [{ kind: "normal", state: cloneState(condition.state) }], fail, errorEffects);
+            for (const exit of bodyExits) {
+                if (exit.kind == "normal" || exit.kind == "continue")
+                    requireSameState(condition.state, exit.state, statement.location, fail);
+                else if (exit.kind == "break") {
+                    requireSameState(condition.state, exit.state, statement.location, fail);
+                    result.push({ kind: "normal", location: statement.location, state: exit.state });
+                }
+                else
+                    result.push(exit);
+            }
+            result.push({ kind: "normal", location: statement.location, state: condition.state });
+        }
+        return mergeEquivalentNormals(result, statement.location, fail);
+    }
+    if (statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement") {
+        const operand = statement.kind == "ForEachStatement" ? statement.list : statement.map;
+        const operands = evaluateExpression(operand, cloneState(state), fail, errorEffects);
+        /** @type {LifetimeExit[]} */
+        const result = operands.filter(({ kind }) => kind != "normal");
+        for (const evaluated of operands.filter(({ kind }) => kind == "normal")) {
+            const bodyExits = analyzeBlock(statement.body, [{ kind: "normal", state: cloneState(evaluated.state) }], fail, errorEffects);
+            for (const exit of bodyExits) {
+                if (exit.kind == "normal" || exit.kind == "continue")
+                    requireSameState(evaluated.state, exit.state, statement.location, fail);
+                else if (exit.kind == "break") {
+                    requireSameState(evaluated.state, exit.state, statement.location, fail);
+                    result.push({ kind: "normal", location: statement.location, state: exit.state });
+                }
+                else
+                    result.push(exit);
+            }
+            result.push({ kind: "normal", location: statement.location, state: evaluated.state });
+        }
+        return mergeEquivalentNormals(result, statement.location, fail);
+    }
+    if (statement.kind == "BreakStatement")
+        return [{ kind: "break", location: statement.location, state: cloneState(state) }];
+    if (statement.kind == "ContinueStatement")
+        return [{ kind: "continue", location: statement.location, state: cloneState(state) }];
+    return [];
+}
+/**
+ * Evaluates one expression with failure states at exact evaluation boundaries.
+ * @param {import("./types.js").Expression} expression - Expression.
+ * @param {Map<string, OwnerState>} state - Incoming ownership state.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function evaluateExpression(expression, state, fail, errorEffects) {
+    if (expression.kind == "OwnedMoveExpression") {
+        const owner = requireOwner(expression.expression.name, state, expression.location, fail);
+        if (owner.kind == "moved")
+            fail("USE_AFTER_MOVE", `Resource '${expression.expression.name}' was already moved.`, expression.location);
+        if (owner.kind == "terminal")
+            fail("USE_AFTER_CLOSE", `Resource '${expression.expression.name}' is terminal after close.`, expression.location);
+        state.set(expression.expression.name, { ...owner, destination: "transfer", kind: "moved" });
+        return [{ kind: "normal", state }];
+    }
+    if (expression.kind == "OwnedBorrowExpression") {
+        const name = placeName(expression.expression);
+        const owner = requireOwner(name, state, expression.location, fail);
+        if (owner.kind == "moved")
+            fail("USE_AFTER_MOVE", `Resource '${name}' was moved before this borrow.`, expression.location);
+        return [{ kind: "normal", state }];
+    }
+    if (expression.kind == "EffectCallExpression")
+        return evaluateEffectCall(expression, state, fail, errorEffects);
+    if (expression.kind == "CallExpression" || expression.kind == "MethodCallExpression" || expression.kind == "ReferenceConstruction") {
+        return evaluateOrdinaryCall(expression, state, fail, errorEffects);
+    }
+    /** @type {LifetimeExit[]} */
+    let flows = [{ kind: "normal", state }];
+    for (const child of expressionChildren(expression))
+        flows = evaluateForFlows(child, flows, fail, errorEffects);
+    return flows;
+}
+/**
+ * Applies one capability operation's declared ownership and failure flow.
+ * @param {import("./types.js").EffectCallExpression} expression - Effect call.
+ * @param {Map<string, OwnerState>} state - Incoming ownership state.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function evaluateEffectCall(expression, state, fail, errorEffects) {
+    /** @type {LifetimeExit[]} */
+    let flows = [{ kind: "normal", state }];
+    for (const argument of expression.arguments)
+        flows = evaluateForFlows(argument, flows, fail, errorEffects);
+    const result = flows.filter(({ kind }) => kind != "normal");
+    const resourceFlow = expression.resolution.resourceFlow;
+    for (const flow of flows.filter(({ kind }) => kind == "normal")) {
+        let operationState = cloneState(flow.state);
+        let terminalFailure;
+        if (resourceFlow.kind == "borrow" || resourceFlow.kind == "close") {
+            const argument = expression.arguments[resourceFlow.parameterIndex];
+            if (argument.kind != "OwnedBorrowExpression")
+                fail("INVALID_RESOURCE_BORROW", "Resource operation lacks an immediate borrow.", argument.location);
+            const name = placeName(argument.expression);
+            const owner = requireOwner(name, operationState, argument.location, fail);
+            if (owner.kind == "moved")
+                fail("USE_AFTER_MOVE", `Resource '${name}' was moved before this operation.`, argument.location);
+            if (owner.kind == "terminal")
+                terminalFailure = resourceFlow.terminalFailureId;
+            else if (resourceFlow.kind == "close")
+                operationState.set(name, { ...owner, closeSiteId: expression.effectSiteId, kind: "terminal" });
+        }
+        if (terminalFailure) {
+            result.push({ errorId: terminalFailure, kind: "raise", location: expression.location, state: operationState });
+            continue;
+        }
+        const failureIds = expression.resolution.failureIds.filter((id) => resourceFlow.kind != "borrow" && resourceFlow.kind != "close" || id != resourceFlow.terminalFailureId);
+        result.push({ kind: "normal", state: cloneState(operationState) });
+        for (const errorId of failureIds) {
+            result.push({ errorId, kind: "raise", location: expression.location, state: cloneState(operationState) });
+        }
+    }
+    return result;
+}
+/**
+ * Applies call-entry ownership commit semantics after ordered argument evaluation.
+ * @param {import("./types.js").CallExpression | import("./types.js").MethodCallExpression | import("./types.js").ReferenceConstruction} expression - Call.
+ * @param {Map<string, OwnerState>} state - Incoming ownership state.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function evaluateOrdinaryCall(expression, state, fail, errorEffects) {
+    const arguments_ = expression.kind == "MethodCallExpression" ? [expression.receiver, ...expression.arguments] : expression.arguments;
+    /** @type {LifetimeExit[]} */
+    let flows = [{ kind: "normal", state }];
+    /** @type {string[]} */
+    const reservedMoves = [];
+    for (const argument of arguments_) {
+        if (argument.kind == "OwnedMoveExpression") {
+            for (const flow of flows.filter(({ kind }) => kind == "normal")) {
+                const owner = requireOwner(argument.expression.name, flow.state, argument.location, fail);
+                if (owner.kind == "moved")
+                    fail("USE_AFTER_MOVE", `Resource '${argument.expression.name}' was already moved.`, argument.location);
+                if (owner.kind == "terminal")
+                    fail("USE_AFTER_CLOSE", `Resource '${argument.expression.name}' is terminal after close.`, argument.location);
+            }
+            if (reservedMoves.includes(argument.expression.name)) {
+                fail("RESOURCE_ALIAS", `Resource '${argument.expression.name}' cannot be transferred to two parameters.`, argument.location);
+            }
+            reservedMoves.push(argument.expression.name);
+        }
+        else
+            flows = evaluateForFlows(argument, flows, fail, errorEffects);
+    }
+    const result = flows.filter(({ kind }) => kind != "normal");
+    for (const flow of flows.filter(({ kind }) => kind == "normal")) {
+        const entered = cloneState(flow.state);
+        for (const name of reservedMoves) {
+            const owner = requireOwner(name, entered, expression.location, fail);
+            if (owner.kind == "moved")
+                fail("USE_AFTER_MOVE", `Resource '${name}' was already moved.`, expression.location);
+            if (owner.kind == "terminal")
+                fail("USE_AFTER_CLOSE", `Resource '${name}' is terminal after close.`, expression.location);
+            entered.set(name, { ...owner, destination: "callee", kind: "moved" });
+        }
+        if (expression.kind == "MethodCallExpression" && expression.resolution?.resourceFlow) {
+            const receiver = expression.receiver.kind == "OwnedBorrowExpression" ? expression.receiver.expression : expression.receiver;
+            if (receiver.kind != "IdentifierExpression" && receiver.kind != "ReceiverExpression" && receiver.kind != "PrivateFieldRead") {
+                fail("INVALID_RESOURCE_BORROW", "Owned method receiver must be an immediate borrowed place.", receiver.location);
+            }
+            const name = placeName(receiver);
+            const owner = requireOwner(name, entered, expression.location, fail);
+            if (owner.kind == "terminal") {
+                if (expression.resolution.resourceFlow.terminalFailureId) {
+                    result.push({ errorId: expression.resolution.resourceFlow.terminalFailureId, kind: "raise",
+                        location: expression.location, state: entered });
+                    continue;
+                }
+                fail("USE_AFTER_CLOSE", `Resource '${name}' is terminal after close.`, expression.location);
+            }
+            if (expression.resolution.resourceFlow.kind == "terminal") {
+                entered.set(name, { ...owner, closeSiteId: expression.effectSiteId ?? expression.location, kind: "terminal" });
+            }
+        }
+        result.push({ kind: "normal", state: cloneState(entered) });
+        const escaping = new Set(expression.failureIds ?? []);
+        if (expression.kind == "CallExpression") {
+            for (const errorId of errorEffects.functions.get(expression.callee) ?? [])
+                escaping.add(errorId);
+        }
+        else if (expression.kind == "MethodCallExpression") {
+            for (const errorId of errorEffects.methods.get(expression.method) ?? [])
+                escaping.add(errorId);
+        }
+        for (const errorId of escaping) {
+            result.push({ errorId, kind: "raise", location: expression.location, state: cloneState(entered) });
+        }
+    }
+    return result;
+}
+/**
+ * Evaluates a child expression only along normal incoming paths.
+ * @param {import("./types.js").Expression} expression - Child expression.
+ * @param {LifetimeExit[]} flows - Incoming paths.
+ * @param {LifetimeFail} fail - Located failure.
+ * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.
+ * @returns {LifetimeExit[]} Reachable exits.
+ */
+function evaluateForFlows(expression, flows, fail, errorEffects) {
+    const result = flows.filter(({ kind }) => kind != "normal");
+    for (const flow of flows.filter(({ kind }) => kind == "normal")) {
+        result.push(...evaluateExpression(expression, cloneState(flow.state), fail, errorEffects));
+    }
+    return result;
+}
+/**
+ * Returns non-call expression children in evaluation order.
+ * @param {import("./types.js").Expression} expression - Parent expression.
+ * @returns {import("./types.js").Expression[]} Children.
+ */
+function expressionChildren(expression) {
+    if (expression.kind == "BinaryExpression")
+        return [expression.left, expression.right];
+    if (expression.kind == "UnaryExpression")
+        return [expression.operand];
+    if (expression.kind == "OptionalSome")
+        return [expression.value];
+    if (expression.kind == "OptionalIsPresent" || expression.kind == "OptionalUnwrap")
+        return [expression.operand];
+    if (expression.kind == "ListLiteral")
+        return expression.elements;
+    if (expression.kind == "MapLiteral" || expression.kind == "OrderedMapLiteral")
+        return expression.entries.map(({ value }) => value);
+    if (expression.kind == "ListIndexExpression")
+        return [expression.collection, expression.index];
+    if (expression.kind == "MapLookupExpression")
+        return [expression.collection, expression.key];
+    if (expression.kind == "CollectionSizeExpression")
+        return [expression.collection];
+    if (expression.kind == "RecordConstruction")
+        return expression.arguments;
+    if (expression.kind == "MemberRead")
+        return [expression.receiver];
+    if (expression.kind == "PrivateFieldRead")
+        return [expression.receiver];
+    if (expression.kind == "ErrorMessageRead")
+        return [expression.receiver];
+    return [];
+}
+/**
+ * Merges normal paths only after proving identical ownership states.
+ * @param {LifetimeExit[]} flows - Candidate paths.
+ * @param {import("./types.js").SourceLocation} location - Join location.
+ * @param {LifetimeFail} fail - Located failure.
+ * @returns {LifetimeExit[]} Merged paths.
+ */
+function mergeEquivalentNormals(flows, location, fail) {
+    const normal = flows.filter(({ kind }) => kind == "normal");
+    if (normal.length > 1) {
+        for (const candidate of normal.slice(1))
+            requireSameState(normal[0].state, candidate.state, location, fail);
+    }
+    return [...flows.filter(({ kind }) => kind != "normal"), ...(normal.length > 0 ? [normal[0]] : [])];
+}
+/**
+ * Requires a finite ownership invariant at a branch or loop join.
+ * @param {Map<string, OwnerState>} left - First ownership state.
+ * @param {Map<string, OwnerState>} right - Second ownership state.
+ * @param {import("./types.js").SourceLocation} location - Join location.
+ * @param {LifetimeFail} fail - Located failure.
+ * @returns {void}
+ */
+function requireSameState(left, right, location, fail) {
+    const names = new Set([...left.keys(), ...right.keys()]);
+    for (const name of names) {
+        const leftState = left.get(name);
+        const rightState = right.get(name);
+        if (leftState?.kind != rightState?.kind || leftState?.originId != rightState?.originId) {
+            fail("RESOURCE_STATE_MISMATCH", `Resource '${name}' has different ownership state across reachable paths.`, location);
+        }
+    }
+}
+/**
+ * Rejects every owned value that leaves its introducing scope open.
+ * @param {Map<string, OwnerState>} state - Ownership state.
+ * @param {Set<string>} names - Owners introduced in the scope.
+ * @param {import("./types.js").SourceLocation} location - Exit location.
+ * @param {LifetimeFail} fail - Located failure.
+ * @returns {void}
+ */
+function checkLeaks(state, names, location, fail) {
+    for (const name of names) {
+        const owner = state.get(name);
+        if (owner?.kind == "open") {
+            const origin = owner.origin;
+            fail("LEAKED_RESOURCE", `Owned resource '${name}' remains open; acquired at ${origin.filename}:${origin.start.line}:${origin.start.column}.`, location);
+        }
+    }
+}
+/**
+ * Resolves an owned place in the current scope.
+ * @param {string} name - Stable place name.
+ * @param {Map<string, OwnerState>} state - Ownership state.
+ * @param {import("./types.js").SourceLocation} location - Use location.
+ * @param {LifetimeFail} fail - Located failure.
+ * @returns {OwnerState} Owner state.
+ */
+function requireOwner(name, state, location, fail) {
+    const owner = state.get(name);
+    if (!owner)
+        return fail("INVALID_RESOURCE_BORROW", `No owned resource place '${name}' is in scope.`, location);
+    return owner;
+}
+/**
+ * Converts an immediate owned expression to a stable place name.
+ * @param {import("./types.js").IdentifierExpression | import("./types.js").ReceiverExpression | import("./types.js").PrivateFieldRead} expression - Owned place.
+ * @returns {string} Place identity.
+ */
+function placeName(expression) {
+    if (expression.kind == "IdentifierExpression")
+        return expression.name;
+    if (expression.kind == "ReceiverExpression")
+        return "this";
+    if (expression.kind == "PrivateFieldRead")
+        return `this.${expression.field}`;
+    return "<invalid>";
+}
+/**
+ * Creates one open ownership state.
+ * @param {string} originId - Deterministic origin identity.
+ * @param {import("./types.js").SourceLocation} origin - Acquisition location.
+ * @returns {OwnerState} Open state.
+ */
+function openState(originId, origin) {
+    return { kind: "open", origin, originId };
+}
+/**
+ * Clones an ownership state for a control-flow fork.
+ * @param {Map<string, OwnerState>} state - State to clone.
+ * @returns {Map<string, OwnerState>} Detached state.
+ */
+function cloneState(state) {
+    return new Map([...state].map(([name, value]) => [name, { ...value }]));
+}
+/**
+ * Checks whether a type carries linear ownership.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @returns {boolean} Whether the type is owned.
+ */
+function isOwned(type) {
+    return type.kind == "OwnedResourceType" || type.kind == "OwnedReferenceType";
+}
+/**
+ * Checks whether the module contains any owned semantic type.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @returns {boolean} Whether lifetime analysis is required.
+ */
+function moduleContainsOwnedType(module) {
+    const pending = [/** @type {unknown} */ (module)];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (!value || typeof value != "object" || seen.has(value))
+            continue;
+        seen.add(value);
+        if (!Array.isArray(value) && (Reflect.get(value, "kind") == "OwnedResourceType" ||
+            Reflect.get(value, "kind") == "OwnedReferenceType"))
+            return true;
+        for (const [key, child] of Object.entries(value)) {
+            if (["location", "provenance", "sourceProvenance"].includes(key))
+                continue;
+            if (Array.isArray(child))
+                pending.push(...child);
+            else if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifetime.js","sourceRoot":"","sources":["../../../src/semantic/lifetime.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @typedef {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never} LifetimeFail */\n/** @typedef {{kind: \"open\", originId: string, origin: import(\"./types.js\").SourceLocation} | {kind: \"moved\", originId: string, origin: import(\"./types.js\").SourceLocation, destination: string} | {kind: \"terminal\", originId: string, origin: import(\"./types.js\").SourceLocation, closeSiteId: string | import(\"./types.js\").SourceLocation}} OwnerState */\n/** @typedef {{kind: \"normal\" | \"return\" | \"raise\" | \"break\" | \"continue\", state: Map<string, OwnerState>, location?: import(\"./types.js\").SourceLocation, errorId?: string}} LifetimeExit */\n\n/**\n * Performs path-sensitive structured lifetime validation for Task 034 owned values.\n * @param {import(\"./types.js\").SemanticModule} module - Fully type-resolved module.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @param {LifetimeFail} fail - Located failure.\n * @returns {void}\n */\nexport function validateResourceLifetimes(module, errorEffects, fail) {\n  if (!(module.capabilities ?? []).some(({resources}) => resources.length > 0) && !moduleContainsOwnedType(module)) return\n\n  for (const declaration of module.classes ?? []) {\n    analyzeOwner(declaration.constructor.parameters, declaration.constructor.body, fail, undefined, errorEffects)\n    for (const method of declaration.methods) analyzeOwner(method.parameters, method.body, fail,\n      declaration.ownership?.kind == \"ownedResource\" ? declaration.ownership.fieldId : undefined, errorEffects)\n  }\n  for (const declaration of module.functions) analyzeOwner(declaration.parameters, declaration.body, fail, undefined, errorEffects)\n  analyzeOwner([], module.entryPoint.body, fail, undefined, errorEffects)\n}\n\n/**\n * Analyzes one function, constructor, method, or entry-point owner.\n * @param {import(\"./types.js\").Parameter[]} parameters - Owned parameters.\n * @param {import(\"./types.js\").Block} body - Structured body.\n * @param {LifetimeFail} fail - Located failure.\n * @param {string | undefined} borrowedFieldId - Owned receiver field, when present.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {void}\n */\nfunction analyzeOwner(parameters, body, fail, borrowedFieldId, errorEffects) {\n  /** @type {Map<string, OwnerState>} */\n  const initial = new Map()\n  const obligations = new Set(parameters.filter(({type}) => isOwned(type)).map(({name}) => name))\n\n  for (const parameter of parameters) {\n    if (isOwned(parameter.type)) initial.set(parameter.name, openState(`parameter:${parameter.name}`, parameter.location))\n  }\n  if (borrowedFieldId) initial.set(`this.${borrowedFieldId}`, openState(`receiver:${borrowedFieldId}`, body.location))\n  const exits = analyzeBlock(body, [{kind: \"normal\", state: initial}], fail, errorEffects)\n\n  for (const exit of exits) checkLeaks(exit.state, obligations, exit.location ?? body.location, fail)\n}\n\n/**\n * Evaluates one lexical block while retaining every abrupt exit separately.\n * @param {import(\"./types.js\").Block} block - Structured block.\n * @param {LifetimeExit[]} incoming - Incoming control-flow states.\n * @param {LifetimeFail} fail - Located failure.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction analyzeBlock(block, incoming, fail, errorEffects) {\n  let active = incoming.filter(({kind}) => kind == \"normal\")\n  const departed = incoming.filter(({kind}) => kind != \"normal\")\n  /** @type {Set<string>} */\n  const locals = new Set()\n\n  for (const statement of block.statements) {\n    if (active.length == 0) break\n    const next = []\n\n    for (const flow of active) next.push(...analyzeStatement(statement, flow.state, fail, locals, errorEffects))\n    departed.push(...next.filter(({kind}) => kind != \"normal\"))\n    active = mergeEquivalentNormals(next.filter(({kind}) => kind == \"normal\"), statement.location, fail)\n  }\n  const exits = [...departed, ...active.map((flow) => ({...flow, location: flow.location ?? block.location}))]\n\n  for (const exit of exits) {\n    checkLeaks(exit.state, locals, exit.location ?? block.location, fail)\n    for (const name of locals) exit.state.delete(name)\n  }\n  return exits\n}\n\n/**\n * Evaluates one statement from one normal state.\n * @param {import(\"./types.js\").Statement} statement - Statement.\n * @param {Map<string, OwnerState>} state - Incoming ownership state.\n * @param {LifetimeFail} fail - Located failure.\n * @param {Set<string>} locals - Locals introduced in the current block.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction analyzeStatement(statement, state, fail, locals, errorEffects) {\n  if (statement.kind == \"LocalDeclaration\") {\n    const flows = evaluateExpression(statement.initializer, cloneState(state), fail, errorEffects)\n\n    if (isOwned(statement.type)) {\n      locals.add(statement.name)\n      for (const flow of flows) {\n        if (flow.kind != \"normal\") continue\n        const origin = statement.initializer.kind == \"OwnedMoveExpression\"\n          ? flow.state.get(statement.initializer.expression.name)?.origin ?? statement.initializer.location\n          : statement.initializer.location\n        flow.state.set(statement.name, openState(`local:${statement.name}`, origin))\n      }\n    }\n    return flows.map((flow) => ({...flow, location: statement.location}))\n  }\n  if (statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") {\n    return evaluateExpression(statement.expression, cloneState(state), fail, errorEffects)\n      .map((flow) => ({...flow, location: statement.location}))\n  }\n  if (statement.kind == \"AssignmentStatement\" || statement.kind == \"PrivateFieldWriteStatement\") {\n    return evaluateExpression(statement.expression, cloneState(state), fail, errorEffects)\n      .map((flow) => ({...flow, location: statement.location}))\n  }\n  if (statement.kind == \"ReturnStatement\") {\n    const flows = statement.expression ? evaluateExpression(statement.expression, cloneState(state), fail, errorEffects) :\n      /** @type {LifetimeExit[]} */ ([{kind: \"normal\", state: cloneState(state)}])\n    return flows.map((flow) => flow.kind == \"normal\"\n      ? {kind: \"return\", location: statement.location, state: flow.state}\n      : {...flow, location: statement.location})\n  }\n  if (statement.kind == \"RaiseStatement\") {\n    const flows = evaluateExpression(statement.error.message, cloneState(state), fail, errorEffects)\n    return flows.map((flow) => flow.kind == \"normal\"\n      ? {errorId: statement.error.error.declarationId, kind: \"raise\", location: statement.location, state: flow.state}\n      : {...flow, location: statement.location})\n  }\n  if (statement.kind == \"IfStatement\") {\n    const conditions = evaluateExpression(statement.condition, cloneState(state), fail, errorEffects)\n    /** @type {LifetimeExit[]} */\n    const result = conditions.filter(({kind}) => kind != \"normal\")\n\n    for (const condition of conditions.filter(({kind}) => kind == \"normal\")) {\n      result.push(...analyzeBlock(statement.consequent, [{kind: \"normal\", state: cloneState(condition.state)}], fail,\n        errorEffects))\n      const alternate = statement.alternate\n        ? analyzeBlock(statement.alternate, [{kind: \"normal\", state: cloneState(condition.state)}], fail, errorEffects)\n        : /** @type {LifetimeExit[]} */ ([{kind: \"normal\", location: statement.location, state: cloneState(condition.state)}])\n\n      result.push(...alternate)\n    }\n    return mergeEquivalentNormals(result, statement.location, fail)\n  }\n  if (statement.kind == \"TryStatement\") {\n    const bodyExits = analyzeBlock(statement.body, [{kind: \"normal\", state: cloneState(state)}], fail, errorEffects)\n    /** @type {LifetimeExit[]} */\n    const result = bodyExits.filter((flow) => flow.kind != \"raise\" || flow.errorId != statement.catchType.declarationId)\n\n    for (const caught of bodyExits.filter((flow) => flow.kind == \"raise\" && flow.errorId == statement.catchType.declarationId)) {\n      result.push(...analyzeBlock(statement.catchBody, [{kind: \"normal\", state: cloneState(caught.state)}], fail, errorEffects))\n    }\n    return mergeEquivalentNormals(result, statement.location, fail)\n  }\n  if (statement.kind == \"WhileStatement\") {\n    const conditions = evaluateExpression(statement.condition, cloneState(state), fail, errorEffects)\n    /** @type {LifetimeExit[]} */\n    const result = conditions.filter(({kind}) => kind != \"normal\")\n\n    for (const condition of conditions.filter(({kind}) => kind == \"normal\")) {\n      const bodyExits = analyzeBlock(statement.body, [{kind: \"normal\", state: cloneState(condition.state)}], fail,\n        errorEffects)\n      for (const exit of bodyExits) {\n        if (exit.kind == \"normal\" || exit.kind == \"continue\") requireSameState(condition.state, exit.state, statement.location, fail)\n        else if (exit.kind == \"break\") {\n          requireSameState(condition.state, exit.state, statement.location, fail)\n          result.push({kind: \"normal\", location: statement.location, state: exit.state})\n        } else result.push(exit)\n      }\n      result.push({kind: \"normal\", location: statement.location, state: condition.state})\n    }\n    return mergeEquivalentNormals(result, statement.location, fail)\n  }\n  if (statement.kind == \"ForEachStatement\" || statement.kind == \"ForEachMapStatement\") {\n    const operand = statement.kind == \"ForEachStatement\" ? statement.list : statement.map\n    const operands = evaluateExpression(operand, cloneState(state), fail, errorEffects)\n    /** @type {LifetimeExit[]} */\n    const result = operands.filter(({kind}) => kind != \"normal\")\n\n    for (const evaluated of operands.filter(({kind}) => kind == \"normal\")) {\n      const bodyExits = analyzeBlock(statement.body, [{kind: \"normal\", state: cloneState(evaluated.state)}], fail,\n        errorEffects)\n      for (const exit of bodyExits) {\n        if (exit.kind == \"normal\" || exit.kind == \"continue\") requireSameState(evaluated.state, exit.state, statement.location, fail)\n        else if (exit.kind == \"break\") {\n          requireSameState(evaluated.state, exit.state, statement.location, fail)\n          result.push({kind: \"normal\", location: statement.location, state: exit.state})\n        } else result.push(exit)\n      }\n      result.push({kind: \"normal\", location: statement.location, state: evaluated.state})\n    }\n    return mergeEquivalentNormals(result, statement.location, fail)\n  }\n  if (statement.kind == \"BreakStatement\") return [{kind: \"break\", location: statement.location, state: cloneState(state)}]\n  if (statement.kind == \"ContinueStatement\") return [{kind: \"continue\", location: statement.location, state: cloneState(state)}]\n\n  return []\n}\n\n/**\n * Evaluates one expression with failure states at exact evaluation boundaries.\n * @param {import(\"./types.js\").Expression} expression - Expression.\n * @param {Map<string, OwnerState>} state - Incoming ownership state.\n * @param {LifetimeFail} fail - Located failure.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction evaluateExpression(expression, state, fail, errorEffects) {\n  if (expression.kind == \"OwnedMoveExpression\") {\n    const owner = requireOwner(expression.expression.name, state, expression.location, fail)\n\n    if (owner.kind == \"moved\") fail(\"USE_AFTER_MOVE\", `Resource '${expression.expression.name}' was already moved.`, expression.location)\n    if (owner.kind == \"terminal\") fail(\"USE_AFTER_CLOSE\", `Resource '${expression.expression.name}' is terminal after close.`, expression.location)\n    state.set(expression.expression.name, {...owner, destination: \"transfer\", kind: \"moved\"})\n    return [{kind: \"normal\", state}]\n  }\n  if (expression.kind == \"OwnedBorrowExpression\") {\n    const name = placeName(expression.expression)\n    const owner = requireOwner(name, state, expression.location, fail)\n\n    if (owner.kind == \"moved\") fail(\"USE_AFTER_MOVE\", `Resource '${name}' was moved before this borrow.`, expression.location)\n    return [{kind: \"normal\", state}]\n  }\n  if (expression.kind == \"EffectCallExpression\") return evaluateEffectCall(expression, state, fail, errorEffects)\n  if (expression.kind == \"CallExpression\" || expression.kind == \"MethodCallExpression\" || expression.kind == \"ReferenceConstruction\") {\n    return evaluateOrdinaryCall(expression, state, fail, errorEffects)\n  }\n\n  /** @type {LifetimeExit[]} */\n  let flows = [{kind: \"normal\", state}]\n  for (const child of expressionChildren(expression)) flows = evaluateForFlows(child, flows, fail, errorEffects)\n  return flows\n}\n\n/**\n * Applies one capability operation's declared ownership and failure flow.\n * @param {import(\"./types.js\").EffectCallExpression} expression - Effect call.\n * @param {Map<string, OwnerState>} state - Incoming ownership state.\n * @param {LifetimeFail} fail - Located failure.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction evaluateEffectCall(expression, state, fail, errorEffects) {\n  /** @type {LifetimeExit[]} */\n  let flows = [{kind: \"normal\", state}]\n\n  for (const argument of expression.arguments) flows = evaluateForFlows(argument, flows, fail, errorEffects)\n  const result = flows.filter(({kind}) => kind != \"normal\")\n  const resourceFlow = expression.resolution.resourceFlow\n\n  for (const flow of flows.filter(({kind}) => kind == \"normal\")) {\n    let operationState = cloneState(flow.state)\n    let terminalFailure\n\n    if (resourceFlow.kind == \"borrow\" || resourceFlow.kind == \"close\") {\n      const argument = expression.arguments[resourceFlow.parameterIndex]\n      if (argument.kind != \"OwnedBorrowExpression\") fail(\"INVALID_RESOURCE_BORROW\", \"Resource operation lacks an immediate borrow.\", argument.location)\n      const name = placeName(argument.expression)\n      const owner = requireOwner(name, operationState, argument.location, fail)\n\n      if (owner.kind == \"moved\") fail(\"USE_AFTER_MOVE\", `Resource '${name}' was moved before this operation.`, argument.location)\n      if (owner.kind == \"terminal\") terminalFailure = resourceFlow.terminalFailureId\n      else if (resourceFlow.kind == \"close\") operationState.set(name, {...owner, closeSiteId: expression.effectSiteId, kind: \"terminal\"})\n    }\n    if (terminalFailure) {\n      result.push({errorId: terminalFailure, kind: \"raise\", location: expression.location, state: operationState})\n      continue\n    }\n    const failureIds = expression.resolution.failureIds.filter((id) =>\n      resourceFlow.kind != \"borrow\" && resourceFlow.kind != \"close\" || id != resourceFlow.terminalFailureId)\n\n    result.push({kind: \"normal\", state: cloneState(operationState)})\n    for (const errorId of failureIds) {\n      result.push({errorId, kind: \"raise\", location: expression.location, state: cloneState(operationState)})\n    }\n  }\n  return result\n}\n\n/**\n * Applies call-entry ownership commit semantics after ordered argument evaluation.\n * @param {import(\"./types.js\").CallExpression | import(\"./types.js\").MethodCallExpression | import(\"./types.js\").ReferenceConstruction} expression - Call.\n * @param {Map<string, OwnerState>} state - Incoming ownership state.\n * @param {LifetimeFail} fail - Located failure.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction evaluateOrdinaryCall(expression, state, fail, errorEffects) {\n  const arguments_ = expression.kind == \"MethodCallExpression\" ? [expression.receiver, ...expression.arguments] : expression.arguments\n  /** @type {LifetimeExit[]} */\n  let flows = [{kind: \"normal\", state}]\n  /** @type {string[]} */\n  const reservedMoves = []\n\n  for (const argument of arguments_) {\n    if (argument.kind == \"OwnedMoveExpression\") {\n      for (const flow of flows.filter(({kind}) => kind == \"normal\")) {\n        const owner = requireOwner(argument.expression.name, flow.state, argument.location, fail)\n        if (owner.kind == \"moved\") fail(\"USE_AFTER_MOVE\", `Resource '${argument.expression.name}' was already moved.`, argument.location)\n        if (owner.kind == \"terminal\") fail(\"USE_AFTER_CLOSE\", `Resource '${argument.expression.name}' is terminal after close.`, argument.location)\n      }\n      if (reservedMoves.includes(argument.expression.name)) {\n        fail(\"RESOURCE_ALIAS\", `Resource '${argument.expression.name}' cannot be transferred to two parameters.`, argument.location)\n      }\n      reservedMoves.push(argument.expression.name)\n    } else flows = evaluateForFlows(argument, flows, fail, errorEffects)\n  }\n  const result = flows.filter(({kind}) => kind != \"normal\")\n\n  for (const flow of flows.filter(({kind}) => kind == \"normal\")) {\n    const entered = cloneState(flow.state)\n    for (const name of reservedMoves) {\n      const owner = requireOwner(name, entered, expression.location, fail)\n      if (owner.kind == \"moved\") fail(\"USE_AFTER_MOVE\", `Resource '${name}' was already moved.`, expression.location)\n      if (owner.kind == \"terminal\") fail(\"USE_AFTER_CLOSE\", `Resource '${name}' is terminal after close.`, expression.location)\n      entered.set(name, {...owner, destination: \"callee\", kind: \"moved\"})\n    }\n    if (expression.kind == \"MethodCallExpression\" && expression.resolution?.resourceFlow) {\n      const receiver = expression.receiver.kind == \"OwnedBorrowExpression\" ? expression.receiver.expression : expression.receiver\n      if (receiver.kind != \"IdentifierExpression\" && receiver.kind != \"ReceiverExpression\" && receiver.kind != \"PrivateFieldRead\") {\n        fail(\"INVALID_RESOURCE_BORROW\", \"Owned method receiver must be an immediate borrowed place.\", receiver.location)\n      }\n      const name = placeName(receiver)\n      const owner = requireOwner(name, entered, expression.location, fail)\n\n      if (owner.kind == \"terminal\") {\n        if (expression.resolution.resourceFlow.terminalFailureId) {\n          result.push({errorId: expression.resolution.resourceFlow.terminalFailureId, kind: \"raise\",\n            location: expression.location, state: entered})\n          continue\n        }\n        fail(\"USE_AFTER_CLOSE\", `Resource '${name}' is terminal after close.`, expression.location)\n      }\n      if (expression.resolution.resourceFlow.kind == \"terminal\") {\n        entered.set(name, {...owner, closeSiteId: expression.effectSiteId ?? expression.location, kind: \"terminal\"})\n      }\n    }\n    result.push({kind: \"normal\", state: cloneState(entered)})\n    const escaping = new Set(expression.failureIds ?? [])\n\n    if (expression.kind == \"CallExpression\") {\n      for (const errorId of errorEffects.functions.get(expression.callee) ?? []) escaping.add(errorId)\n    } else if (expression.kind == \"MethodCallExpression\") {\n      for (const errorId of errorEffects.methods.get(expression.method) ?? []) escaping.add(errorId)\n    }\n    for (const errorId of escaping) {\n      result.push({errorId, kind: \"raise\", location: expression.location, state: cloneState(entered)})\n    }\n  }\n  return result\n}\n\n/**\n * Evaluates a child expression only along normal incoming paths.\n * @param {import(\"./types.js\").Expression} expression - Child expression.\n * @param {LifetimeExit[]} flows - Incoming paths.\n * @param {LifetimeFail} fail - Located failure.\n * @param {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} errorEffects - Complete escaping error sets per function and method.\n * @returns {LifetimeExit[]} Reachable exits.\n */\nfunction evaluateForFlows(expression, flows, fail, errorEffects) {\n  const result = flows.filter(({kind}) => kind != \"normal\")\n  for (const flow of flows.filter(({kind}) => kind == \"normal\")) {\n    result.push(...evaluateExpression(expression, cloneState(flow.state), fail, errorEffects))\n  }\n  return result\n}\n\n/**\n * Returns non-call expression children in evaluation order.\n * @param {import(\"./types.js\").Expression} expression - Parent expression.\n * @returns {import(\"./types.js\").Expression[]} Children.\n */\nfunction expressionChildren(expression) {\n  if (expression.kind == \"BinaryExpression\") return [expression.left, expression.right]\n  if (expression.kind == \"UnaryExpression\") return [expression.operand]\n  if (expression.kind == \"OptionalSome\") return [expression.value]\n  if (expression.kind == \"OptionalIsPresent\" || expression.kind == \"OptionalUnwrap\") return [expression.operand]\n  if (expression.kind == \"ListLiteral\") return expression.elements\n  if (expression.kind == \"MapLiteral\" || expression.kind == \"OrderedMapLiteral\") return expression.entries.map(({value}) => value)\n  if (expression.kind == \"ListIndexExpression\") return [expression.collection, expression.index]\n  if (expression.kind == \"MapLookupExpression\") return [expression.collection, expression.key]\n  if (expression.kind == \"CollectionSizeExpression\") return [expression.collection]\n  if (expression.kind == \"RecordConstruction\") return expression.arguments\n  if (expression.kind == \"MemberRead\") return [expression.receiver]\n  if (expression.kind == \"PrivateFieldRead\") return [expression.receiver]\n  if (expression.kind == \"ErrorMessageRead\") return [expression.receiver]\n  return []\n}\n\n/**\n * Merges normal paths only after proving identical ownership states.\n * @param {LifetimeExit[]} flows - Candidate paths.\n * @param {import(\"./types.js\").SourceLocation} location - Join location.\n * @param {LifetimeFail} fail - Located failure.\n * @returns {LifetimeExit[]} Merged paths.\n */\nfunction mergeEquivalentNormals(flows, location, fail) {\n  const normal = flows.filter(({kind}) => kind == \"normal\")\n  if (normal.length > 1) {\n    for (const candidate of normal.slice(1)) requireSameState(normal[0].state, candidate.state, location, fail)\n  }\n  return [...flows.filter(({kind}) => kind != \"normal\"), ...(normal.length > 0 ? [normal[0]] : [])]\n}\n\n/**\n * Requires a finite ownership invariant at a branch or loop join.\n * @param {Map<string, OwnerState>} left - First ownership state.\n * @param {Map<string, OwnerState>} right - Second ownership state.\n * @param {import(\"./types.js\").SourceLocation} location - Join location.\n * @param {LifetimeFail} fail - Located failure.\n * @returns {void}\n */\nfunction requireSameState(left, right, location, fail) {\n  const names = new Set([...left.keys(), ...right.keys()])\n  for (const name of names) {\n    const leftState = left.get(name)\n    const rightState = right.get(name)\n    if (leftState?.kind != rightState?.kind || leftState?.originId != rightState?.originId) {\n      fail(\"RESOURCE_STATE_MISMATCH\", `Resource '${name}' has different ownership state across reachable paths.`, location)\n    }\n  }\n}\n\n/**\n * Rejects every owned value that leaves its introducing scope open.\n * @param {Map<string, OwnerState>} state - Ownership state.\n * @param {Set<string>} names - Owners introduced in the scope.\n * @param {import(\"./types.js\").SourceLocation} location - Exit location.\n * @param {LifetimeFail} fail - Located failure.\n * @returns {void}\n */\nfunction checkLeaks(state, names, location, fail) {\n  for (const name of names) {\n    const owner = state.get(name)\n    if (owner?.kind == \"open\") {\n      const origin = owner.origin\n      fail(\"LEAKED_RESOURCE\", `Owned resource '${name}' remains open; acquired at ${origin.filename}:${origin.start.line}:${origin.start.column}.`, location)\n    }\n  }\n}\n\n/**\n * Resolves an owned place in the current scope.\n * @param {string} name - Stable place name.\n * @param {Map<string, OwnerState>} state - Ownership state.\n * @param {import(\"./types.js\").SourceLocation} location - Use location.\n * @param {LifetimeFail} fail - Located failure.\n * @returns {OwnerState} Owner state.\n */\nfunction requireOwner(name, state, location, fail) {\n  const owner = state.get(name)\n  if (!owner) return fail(\"INVALID_RESOURCE_BORROW\", `No owned resource place '${name}' is in scope.`, location)\n  return owner\n}\n\n/**\n * Converts an immediate owned expression to a stable place name.\n * @param {import(\"./types.js\").IdentifierExpression | import(\"./types.js\").ReceiverExpression | import(\"./types.js\").PrivateFieldRead} expression - Owned place.\n * @returns {string} Place identity.\n */\nfunction placeName(expression) {\n  if (expression.kind == \"IdentifierExpression\") return expression.name\n  if (expression.kind == \"ReceiverExpression\") return \"this\"\n  if (expression.kind == \"PrivateFieldRead\") return `this.${expression.field}`\n  return \"<invalid>\"\n}\n\n/**\n * Creates one open ownership state.\n * @param {string} originId - Deterministic origin identity.\n * @param {import(\"./types.js\").SourceLocation} origin - Acquisition location.\n * @returns {OwnerState} Open state.\n */\nfunction openState(originId, origin) {\n  return {kind: \"open\", origin, originId}\n}\n\n/**\n * Clones an ownership state for a control-flow fork.\n * @param {Map<string, OwnerState>} state - State to clone.\n * @returns {Map<string, OwnerState>} Detached state.\n */\nfunction cloneState(state) {\n  return new Map([...state].map(([name, value]) => [name, {...value}]))\n}\n\n/**\n * Checks whether a type carries linear ownership.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @returns {boolean} Whether the type is owned.\n */\nfunction isOwned(type) {\n  return type.kind == \"OwnedResourceType\" || type.kind == \"OwnedReferenceType\"\n}\n\n/**\n * Checks whether the module contains any owned semantic type.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @returns {boolean} Whether lifetime analysis is required.\n */\nfunction moduleContainsOwnedType(module) {\n  const pending = [/** @type {unknown} */ (module)]\n  const seen = new Set()\n\n  while (pending.length > 0) {\n    const value = pending.pop()\n\n    if (!value || typeof value != \"object\" || seen.has(value)) continue\n    seen.add(value)\n    if (!Array.isArray(value) && (Reflect.get(value, \"kind\") == \"OwnedResourceType\" ||\n      Reflect.get(value, \"kind\") == \"OwnedReferenceType\")) return true\n    for (const [key, child] of Object.entries(value)) {\n      if ([\"location\", \"provenance\", \"sourceProvenance\"].includes(key)) continue\n      if (Array.isArray(child)) pending.push(...child)\n      else if (child && typeof child == \"object\") pending.push(child)\n    }\n  }\n  return false\n}\n"]}