@tsonic/frontend 0.0.73 → 0.0.75

package/dist/ir/validation/numeric-proof-pass.js

@@ -1,10 +1,10 @@
 /**
  * Numeric Proof Pass - HARD GATE for numeric type narrowings
  *
- * This pass runs before emission and:
- * 1. Validates all numeric narrowings are provable
- * 2. Attaches NumericProof to validated expressions
- * 3. Emits error diagnostics for unprovable narrowings
+ * Facade module that re-exports from focused sub-modules:
+ * - numeric-proof-analysis.ts: Type inference, guard facts, literal proofs
+ * - numeric-proof-proving.ts: Narrowing proof construction
+ * - numeric-proof-walk.ts: IR tree traversal and proof attachment
  *
  * CRITICAL: If this pass emits ANY errors, the emitter MUST NOT run.
  * Unlike the previous implementation, this pass does NOT allow fallback casts.
@@ -13,1164 +13,5 @@
  * This follows Alice's "Provably-Sound Numeric Types" specification:
  * "If Tsonic cannot prove a numeric narrowing is sound, it must fail compilation."
  */
-import { createDiagnostic, } from "../../types/diagnostic.js";
-import { NUMERIC_RANGES, getBinaryResultKind, isIntegerKind, TSONIC_TO_NUMERIC_KIND, isValidIntegerLexeme, parseBigIntFromRaw, bigIntFitsInKind, isWideningConversion, } from "../types.js";
-/**
- * Create a source location for a module
- */
-const moduleLocation = (ctx) => ({
-    file: ctx.filePath,
-    line: 1,
-    column: 1,
-    length: 1,
-});
-const INT32_RANGE = NUMERIC_RANGES.get("Int32");
-const cloneProofContext = (ctx) => ({
-    ...ctx,
-    provenVariables: new Map(ctx.provenVariables),
-    provenParameters: new Map(ctx.provenParameters),
-});
-const extractIntegerLiteralBound = (expr) => {
-    if (expr.kind === "literal" && typeof expr.value === "number") {
-        if (expr.raw !== undefined && isValidIntegerLexeme(expr.raw)) {
-            return parseBigIntFromRaw(expr.raw);
-        }
-        if (Number.isInteger(expr.value)) {
-            return BigInt(expr.value);
-        }
-        return undefined;
-    }
-    if (expr.kind === "unary" &&
-        (expr.operator === "-" || expr.operator === "+") &&
-        expr.expression.kind === "literal" &&
-        typeof expr.expression.value === "number") {
-        const inner = extractIntegerLiteralBound(expr.expression);
-        if (inner === undefined)
-            return undefined;
-        return expr.operator === "-" ? -inner : inner;
-    }
-    return undefined;
-};
-const isIdentifierExpr = (expr) => expr.kind === "identifier";
-const memberAccessName = (expr) => {
-    if (expr.kind !== "memberAccess" || expr.isComputed) {
-        return undefined;
-    }
-    return typeof expr.property === "string"
-        ? expr.property
-        : expr.property.kind === "literal" &&
-            typeof expr.property.value === "string"
-            ? expr.property.value
-            : undefined;
-};
-const extractNumberIsIntegerFact = (expr) => {
-    if (expr.kind !== "call" || expr.arguments.length !== 1) {
-        return undefined;
-    }
-    const callee = expr.callee;
-    if (callee.kind !== "memberAccess" ||
-        !isIdentifierExpr(callee.object) ||
-        callee.object.name !== "Number" ||
-        memberAccessName(callee) !== "isInteger") {
-        return undefined;
-    }
-    const arg = expr.arguments[0];
-    if (!arg || !isIdentifierExpr(arg)) {
-        return undefined;
-    }
-    return [arg.name, { integerChecked: true }];
-};
-const extractInt32BoundFact = (expr) => {
-    if (expr.kind !== "binary") {
-        return undefined;
-    }
-    const directIdentifier = isIdentifierExpr(expr.left) &&
-        extractIntegerLiteralBound(expr.right) !== undefined
-        ? {
-            name: expr.left.name,
-            bound: extractIntegerLiteralBound(expr.right),
-            operator: expr.operator,
-            reversed: false,
-        }
-        : isIdentifierExpr(expr.right) &&
-            extractIntegerLiteralBound(expr.left) !== undefined
-            ? {
-                name: expr.right.name,
-                bound: extractIntegerLiteralBound(expr.left),
-                operator: expr.operator,
-                reversed: true,
-            }
-            : undefined;
-    if (!directIdentifier) {
-        return undefined;
-    }
-    const { name, bound, operator, reversed } = directIdentifier;
-    const effectiveOperator = reversed
-        ? operator === ">="
-            ? "<="
-            : operator === ">"
-                ? "<"
-                : operator === "<="
-                    ? ">="
-                    : operator === "<"
-                        ? ">"
-                        : operator
-        : operator;
-    switch (effectiveOperator) {
-        case ">=":
-            return [name, { integerChecked: false, lowerBound: bound }];
-        case ">":
-            return [name, { integerChecked: false, lowerBound: bound + 1n }];
-        case "<=":
-            return [name, { integerChecked: false, upperBound: bound }];
-        case "<":
-            return [name, { integerChecked: false, upperBound: bound - 1n }];
-        default:
-            return undefined;
-    }
-};
-const mergeInt32GuardFact = (left, right) => ({
-    integerChecked: (left?.integerChecked ?? false) || right.integerChecked,
-    lowerBound: left?.lowerBound === undefined
-        ? right.lowerBound
-        : right.lowerBound === undefined
-            ? left.lowerBound
-            : left.lowerBound > right.lowerBound
-                ? left.lowerBound
-                : right.lowerBound,
-    upperBound: left?.upperBound === undefined
-        ? right.upperBound
-        : right.upperBound === undefined
-            ? left.upperBound
-            : left.upperBound < right.upperBound
-                ? left.upperBound
-                : right.upperBound,
-});
-const collectInt32GuardFactsInTruthyCondition = (expr) => {
-    if (expr.kind === "logical" && expr.operator === "&&") {
-        const out = new Map();
-        for (const [name, fact] of collectInt32GuardFactsInTruthyCondition(expr.left)) {
-            out.set(name, fact);
-        }
-        for (const [name, fact] of collectInt32GuardFactsInTruthyCondition(expr.right)) {
-            out.set(name, mergeInt32GuardFact(out.get(name), fact));
-        }
-        return out;
-    }
-    const integerFact = extractNumberIsIntegerFact(expr);
-    if (integerFact) {
-        return new Map([[integerFact[0], integerFact[1]]]);
-    }
-    const boundFact = extractInt32BoundFact(expr);
-    if (boundFact) {
-        return new Map([[boundFact[0], boundFact[1]]]);
-    }
-    return new Map();
-};
-const withInt32ProofsFromTruthyCondition = (ctx, condition) => {
-    if (!INT32_RANGE) {
-        return ctx;
-    }
-    const facts = collectInt32GuardFactsInTruthyCondition(condition);
-    if (facts.size === 0) {
-        return ctx;
-    }
-    const next = cloneProofContext(ctx);
-    for (const [name, fact] of facts) {
-        if (fact.integerChecked &&
-            fact.lowerBound !== undefined &&
-            fact.upperBound !== undefined &&
-            fact.lowerBound >= INT32_RANGE.min &&
-            fact.upperBound <= INT32_RANGE.max) {
-            next.provenVariables.set(name, "Int32");
-        }
-    }
-    return next;
-};
-/**
- * Extract NumericKind from an IrType if it represents a known numeric type
- *
- * INVARIANT: "int" is a distinct primitive type (primitiveType(name="int")),
- * NOT primitiveType(name="number") with numericIntent.
- */
-const getNumericKindFromType = (type) => {
-    if (type === undefined) {
-        return undefined;
-    }
-    // Nullable numeric forms (e.g., int | undefined, long | null) should preserve
-    // the underlying numeric kind for proof purposes.
-    if (type.kind === "unionType") {
-        const nonNullish = type.types.filter((t) => !(t.kind === "primitiveType" &&
-            (t.name === "null" || t.name === "undefined")));
-        if (nonNullish.length === 1) {
-            const only = nonNullish[0];
-            return only ? getNumericKindFromType(only) : undefined;
-        }
-        return undefined;
-    }
-    // Check for primitiveType(name="int") - distinct integer primitive
-    if (type.kind === "primitiveType" && type.name === "int") {
-        return "Int32";
-    }
-    // Check for referenceType with known numeric type name (e.g., long, float, byte)
-    // Use the TSONIC_TO_NUMERIC_KIND map from ir/types
-    if (type.kind === "referenceType") {
-        return TSONIC_TO_NUMERIC_KIND.get(type.name);
-    }
-    return undefined;
-};
-/**
- * Try to infer the numeric kind of an expression.
- * Returns undefined if the expression's numeric kind cannot be determined.
- *
- * For literals: follows C# semantics where integer-looking literals default to int.
- * A literal is Int32 if: no decimal point, no exponent, fits in Int32 range.
- * Otherwise it's Double.
- */
-const inferNumericKind = (expr, ctx) => {
-    switch (expr.kind) {
-        case "literal": {
-            if (typeof expr.value === "number") {
-                // Check if inferred type has explicit numeric intent (from annotation)
-                const typeKind = getNumericKindFromType(expr.inferredType);
-                if (typeKind !== undefined) {
-                    return typeKind;
-                }
-                // For bare literals, follow C# semantics:
-                // Integer-looking literals (no decimal, no exponent) are Int32/Int64 if in range
-                // Otherwise, they're Double
-                if (expr.raw !== undefined && isValidIntegerLexeme(expr.raw)) {
-                    const bigValue = parseBigIntFromRaw(expr.raw);
-                    if (bigValue !== undefined) {
-                        if (bigIntFitsInKind(bigValue, "Int32")) {
-                            return "Int32";
-                        }
-                        if (bigIntFitsInKind(bigValue, "Int64")) {
-                            return "Int64";
-                        }
-                    }
-                }
-                // Floating-point or out-of-range integer literals are Double
-                return "Double";
-            }
-            return undefined;
-        }
-        case "identifier": {
-            // Check if this variable is proven
-            const varKind = ctx.provenVariables.get(expr.name);
-            if (varKind !== undefined) {
-                return varKind;
-            }
-            // Check if this is a parameter
-            const paramKind = ctx.provenParameters.get(expr.name);
-            if (paramKind !== undefined) {
-                return paramKind;
-            }
-            // Check inferredType for CLR-typed identifiers
-            return getNumericKindFromType(expr.inferredType);
-        }
-        case "numericNarrowing": {
-            // The target kind of the narrowing is the proven kind (if proof exists)
-            if (expr.proof) {
-                return expr.proof.kind;
-            }
-            // Fall back to targetKind - the narrowing declares intent even without proof
-            // This handles cases where we're inferring before proof is attached
-            return expr.targetKind;
-        }
-        case "binary": {
-            // Binary operators follow C# promotion rules
-            const leftKind = inferNumericKind(expr.left, ctx);
-            const rightKind = inferNumericKind(expr.right, ctx);
-            if (leftKind !== undefined && rightKind !== undefined) {
-                return getBinaryResultKind(leftKind, rightKind);
-            }
-            return undefined;
-        }
-        case "unary": {
-            if (expr.operator === "-" ||
-                expr.operator === "+" ||
-                expr.operator === "~") {
-                return inferNumericKind(expr.expression, ctx);
-            }
-            return undefined;
-        }
-        case "conditional": {
-            const trueKind = inferNumericKind(expr.whenTrue, ctx);
-            const falseKind = inferNumericKind(expr.whenFalse, ctx);
-            if (trueKind === falseKind) {
-                return trueKind;
-            }
-            if (trueKind !== undefined && falseKind !== undefined) {
-                return getBinaryResultKind(trueKind, falseKind);
-            }
-            return undefined;
-        }
-        case "logical": {
-            // `??` preserves the left kind when present, otherwise uses the right kind.
-            // For proof, we require both sides to be numerically provable and derive
-            // a deterministic promoted kind.
-            if (expr.operator === "??") {
-                const leftKind = inferNumericKind(expr.left, ctx);
-                const rightKind = inferNumericKind(expr.right, ctx);
-                if (leftKind === rightKind)
-                    return leftKind;
-                if (leftKind !== undefined && rightKind !== undefined) {
-                    return getBinaryResultKind(leftKind, rightKind);
-                }
-            }
-            return undefined;
-        }
-        case "call": {
-            // Check if the call has a numeric return type from CLR metadata
-            return getNumericKindFromType(expr.inferredType);
-        }
-        case "memberAccess": {
-            return getNumericKindFromType(expr.inferredType);
-        }
-        default:
-            return undefined;
-    }
-};
-/**
- * Attempt to prove that a literal fits in a target numeric kind.
- * Uses the raw lexeme for integer validation (NOT the JS number).
- */
-const proveLiteral = (value, raw, targetKind, ctx, sourceSpan) => {
-    const location = sourceSpan ?? moduleLocation(ctx);
-    // For floating-point targets, any finite number works
-    if (!isIntegerKind(targetKind)) {
-        if (!Number.isFinite(value)) {
-            ctx.diagnostics.push(createDiagnostic("TSN5102", "error", `Literal ${value} cannot be proven as ${targetKind}: not a finite number`, location, "Only finite numbers can be used as floating-point types."));
-            return undefined;
-        }
-        return {
-            kind: targetKind,
-            source: { type: "literal", value },
-        };
-    }
-    // For integer targets, we MUST have the raw lexeme
-    if (raw === undefined) {
-        ctx.diagnostics.push(createDiagnostic("TSN5102", "error", `Cannot prove literal as ${targetKind}: raw lexeme not available`, location, "Integer literal proofs require the source lexeme for precision."));
-        return undefined;
-    }
-    // Check that the lexeme represents an integer (no decimal, no exponent)
-    if (!isValidIntegerLexeme(raw)) {
-        ctx.diagnostics.push(createDiagnostic("TSN5102", "error", `Literal '${raw}' cannot be proven as ${targetKind}: not an integer lexeme`, location, "Use an integer literal (no decimal point or exponent), or use float/double."));
-        return undefined;
-    }
-    // Parse as BigInt for precise range checking
-    const bigValue = parseBigIntFromRaw(raw);
-    if (bigValue === undefined) {
-        ctx.diagnostics.push(createDiagnostic("TSN5102", "error", `Cannot parse literal '${raw}' as integer`, location, "The literal could not be parsed as an integer value."));
-        return undefined;
-    }
-    // JS Safe Integer check: Literals > 2^53-1 lose precision in JavaScript
-    // This is a representation soundness check - the TypeScript parser may have
-    // already lost precision by the time we see the JS number value.
-    const JS_MAX_SAFE_INTEGER = BigInt("9007199254740991"); // 2^53 - 1
-    const JS_MIN_SAFE_INTEGER = BigInt("-9007199254740991"); // -(2^53 - 1)
-    if (bigValue > JS_MAX_SAFE_INTEGER || bigValue < JS_MIN_SAFE_INTEGER) {
-        ctx.diagnostics.push(createDiagnostic("TSN5108", "error", `Literal ${raw} exceeds JavaScript safe integer range (±${JS_MAX_SAFE_INTEGER})`, location, "Values outside ±2^53-1 cannot be exactly represented in JavaScript. " +
-            "Use BigInt literals (e.g., 9007199254740992n) or string parsing."));
-        return undefined;
-    }
-    // Check range
-    if (!bigIntFitsInKind(bigValue, targetKind)) {
-        const range = NUMERIC_RANGES.get(targetKind);
-        ctx.diagnostics.push(createDiagnostic("TSN5102", "error", `Literal ${raw} is out of range for type ${targetKind} (valid range: ${range?.min} to ${range?.max})`, location, `Value must be in range ${range?.min} to ${range?.max} for ${targetKind}.`));
-        return undefined;
-    }
-    return {
-        kind: targetKind,
-        source: { type: "literal", value: bigValue },
-    };
-};
-/**
- * Attempt to prove a numeric narrowing expression.
- * If proof fails, emits an error diagnostic - NO FALLBACK TO CAST.
- */
-const proveNarrowing = (expr, ctx) => {
-    const innerExpr = expr.expression;
-    const targetKind = expr.targetKind;
-    // Use expression's sourceSpan if available, otherwise fall back to module location
-    const location = expr.sourceSpan ?? innerExpr.sourceSpan ?? moduleLocation(ctx);
-    // Case 1: Inner expression is a literal
-    if (innerExpr.kind === "literal" && typeof innerExpr.value === "number") {
-        const proof = proveLiteral(innerExpr.value, innerExpr.raw, targetKind, ctx, innerExpr.sourceSpan ?? location);
-        if (proof === undefined) {
-            // proveLiteral already pushed the diagnostic
-            return undefined;
-        }
-        return proof;
-    }
-    // Case 2: Inner expression is an identifier that is already proven
-    if (innerExpr.kind === "identifier") {
-        const varKind = ctx.provenVariables.get(innerExpr.name);
-        const paramKind = ctx.provenParameters.get(innerExpr.name);
-        const sourceKind = varKind ?? paramKind;
-        if (sourceKind !== undefined) {
-            if (sourceKind === targetKind) {
-                return {
-                    kind: targetKind,
-                    source: { type: "variable", name: innerExpr.name },
-                };
-            }
-            // Check if this is a widening conversion (e.g., int → long)
-            if (isWideningConversion(sourceKind, targetKind)) {
-                return {
-                    kind: targetKind,
-                    source: { type: "variable", name: innerExpr.name },
-                };
-            }
-            // Narrowing conversion - this is an error
-            ctx.diagnostics.push(createDiagnostic("TSN5104", "error", `Cannot narrow '${innerExpr.name}' from ${sourceKind} to ${targetKind}`, innerExpr.sourceSpan ?? location, `Variable '${innerExpr.name}' is proven as ${sourceKind}. ` +
-                `Narrowing conversions require explicit handling.`));
-            return undefined;
-        }
-        // Identifier not in proven scope - check if it has numeric intent from CLR
-        const identKind = getNumericKindFromType(innerExpr.inferredType);
-        if (identKind !== undefined) {
-            if (identKind === targetKind ||
-                isWideningConversion(identKind, targetKind)) {
-                return {
-                    kind: targetKind,
-                    source: { type: "variable", name: innerExpr.name },
-                };
-            }
-        }
-        // Cannot prove this identifier
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing of '${innerExpr.name}' to ${targetKind}`, innerExpr.sourceSpan ?? location, `Expression '${innerExpr.name}' has unknown numeric kind. ` +
-            `Narrow using \`${innerExpr.name} as ${targetKind}\` at assignment, ` +
-            `or ensure it originates from a proven ${targetKind} source.`));
-        return undefined;
-    }
-    // Case 3: Inner expression is a binary operation
-    if (innerExpr.kind === "binary") {
-        const leftKind = inferNumericKind(innerExpr.left, ctx);
-        const rightKind = inferNumericKind(innerExpr.right, ctx);
-        if (leftKind !== undefined && rightKind !== undefined) {
-            const resultKind = getBinaryResultKind(leftKind, rightKind);
-            if (resultKind === targetKind) {
-                return {
-                    kind: targetKind,
-                    source: {
-                        type: "binaryOp",
-                        operator: innerExpr.operator,
-                        leftKind,
-                        rightKind,
-                    },
-                };
-            }
-            // Result kind doesn't match target - error
-            ctx.diagnostics.push(createDiagnostic("TSN5103", "error", `Binary '${leftKind} ${innerExpr.operator} ${rightKind}' produces ${resultKind}, not ${targetKind}`, innerExpr.sourceSpan ?? location, `C# promotion rules: ${leftKind} ${innerExpr.operator} ${rightKind} = ${resultKind}. ` +
-                `Cast operands to ${targetKind} first if needed.`));
-            return undefined;
-        }
-        // Fallback for explicit narrowing of binary expressions:
-        // if the binary node itself already carries deterministic numeric intent,
-        // accept `(...binary...) as <targetKind>` as an explicit cast for
-        // opaque producer operands (e.g. conversion calls) where operand-level
-        // kind recovery is intentionally conservative.
-        const isOpaqueNumericProducer = (expression) => expression.kind === "call" ||
-            expression.kind === "memberAccess" ||
-            expression.kind === "await";
-        const inferredBinaryKind = getNumericKindFromType(innerExpr.inferredType) ??
-            (innerExpr.inferredType?.kind === "primitiveType" &&
-                innerExpr.inferredType.name === "number"
-                ? "Double"
-                : undefined);
-        if (inferredBinaryKind !== undefined &&
-            isOpaqueNumericProducer(innerExpr.left) &&
-            isOpaqueNumericProducer(innerExpr.right)) {
-            return {
-                kind: targetKind,
-                source: { type: "narrowing", from: inferredBinaryKind },
-            };
-        }
-        // Cannot determine operand kinds
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing of binary expression to ${targetKind}`, innerExpr.sourceSpan ?? location, "One or both operands have unknown numeric kind. " +
-            "Ensure all operands are proven numeric types."));
-        return undefined;
-    }
-    // Case 4: Inner expression is a unary operation
-    if (innerExpr.kind === "unary") {
-        if (innerExpr.operator === "-" ||
-            innerExpr.operator === "+" ||
-            innerExpr.operator === "~") {
-            const operandKind = inferNumericKind(innerExpr.expression, ctx);
-            if (operandKind !== undefined && operandKind === targetKind) {
-                return {
-                    kind: targetKind,
-                    source: {
-                        type: "unaryOp",
-                        operator: innerExpr.operator,
-                        operandKind,
-                    },
-                };
-            }
-        }
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing of unary expression to ${targetKind}`, innerExpr.sourceSpan ?? location, "Unary expression has unknown or mismatched numeric kind. " +
-            "Ensure the operand is a proven numeric type."));
-        return undefined;
-    }
-    // Case 5: Inner expression is another numeric narrowing (nested)
-    if (innerExpr.kind === "numericNarrowing") {
-        if (innerExpr.proof !== undefined && innerExpr.proof.kind === targetKind) {
-            return {
-                kind: targetKind,
-                source: { type: "narrowing", from: innerExpr.proof.kind },
-            };
-        }
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove nested narrowing to ${targetKind}`, innerExpr.sourceSpan ?? location, "Inner narrowing is unproven or has different kind."));
-        return undefined;
-    }
-    // Case 6: Inner expression is a call with known return type from CLR
-    if (innerExpr.kind === "call") {
-        const returnKind = getNumericKindFromType(innerExpr.inferredType);
-        if (returnKind !== undefined && returnKind === targetKind) {
-            const methodName = innerExpr.callee.kind === "memberAccess" &&
-                typeof innerExpr.callee.property === "string"
-                ? innerExpr.callee.property
-                : "unknown";
-            return {
-                kind: targetKind,
-                source: { type: "dotnetReturn", method: methodName, returnKind },
-            };
-        }
-    }
-    // Case 7: Inner expression is a member access with known type
-    if (innerExpr.kind === "memberAccess") {
-        const memberKind = getNumericKindFromType(innerExpr.inferredType);
-        if (memberKind !== undefined && memberKind === targetKind) {
-            const propName = typeof innerExpr.property === "string"
-                ? innerExpr.property
-                : "computed";
-            return {
-                kind: targetKind,
-                source: {
-                    type: "dotnetReturn",
-                    method: propName,
-                    returnKind: memberKind,
-                },
-            };
-        }
-    }
-    // Case 8: Inner expression is nullish coalescing on numeric values
-    if (innerExpr.kind === "logical" && innerExpr.operator === "??") {
-        const leftKind = inferNumericKind(innerExpr.left, ctx);
-        const rightKind = inferNumericKind(innerExpr.right, ctx);
-        if (leftKind !== undefined && rightKind !== undefined) {
-            const resultKind = leftKind === rightKind
-                ? leftKind
-                : getBinaryResultKind(leftKind, rightKind);
-            if (resultKind === targetKind ||
-                isWideningConversion(resultKind, targetKind)) {
-                return {
-                    kind: targetKind,
-                    source: {
-                        type: "binaryOp",
-                        operator: "??",
-                        leftKind,
-                        rightKind,
-                    },
-                };
-            }
-            ctx.diagnostics.push(createDiagnostic("TSN5103", "error", `Nullish coalescing '${leftKind} ?? ${rightKind}' produces ${resultKind}, not ${targetKind}`, innerExpr.sourceSpan ?? location, `Ensure both branches are provably ${targetKind} (or widen explicitly).`));
-            return undefined;
-        }
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing of nullish coalescing expression to ${targetKind}`, innerExpr.sourceSpan ?? location, "Left/right branches must both be provable numeric kinds."));
-        return undefined;
-    }
-    // Case 9: Inner expression is a conditional expression with deterministic
-    // numeric branch result.
-    if (innerExpr.kind === "conditional") {
-        const resultKind = inferNumericKind(innerExpr, ctx);
-        if (resultKind !== undefined) {
-            if (resultKind === targetKind ||
-                isWideningConversion(resultKind, targetKind)) {
-                return {
-                    kind: targetKind,
-                    source: { type: "narrowing", from: resultKind },
-                };
-            }
-            ctx.diagnostics.push(createDiagnostic("TSN5103", "error", `Conditional expression produces ${resultKind}, not ${targetKind}`, innerExpr.sourceSpan ?? location, `Ensure both conditional branches are provably ${targetKind} (or widen explicitly).`));
-            return undefined;
-        }
-        ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing of conditional expression to ${targetKind}`, innerExpr.sourceSpan ?? location, "Both conditional branches must be provable numeric kinds."));
-        return undefined;
-    }
-    // HARD GATE: Cannot prove - emit error, DO NOT fallback to cast
-    ctx.diagnostics.push(createDiagnostic("TSN5101", "error", `Cannot prove narrowing to ${targetKind}`, location, `Expression of kind '${innerExpr.kind}' cannot be proven to produce ${targetKind}. ` +
-        `Ensure the expression is a literal in range, a variable with known numeric type, ` +
-        `or a binary/unary operation on proven numeric operands.`));
-    return undefined;
-};
-/**
- * Process an expression, proving numeric narrowings and returning
- * the expression with proofs attached.
- */
-const processExpression = (expr, ctx) => {
-    switch (expr.kind) {
-        case "numericNarrowing": {
-            const processedInner = processExpression(expr.expression, ctx);
-            const proof = proveNarrowing({ ...expr, expression: processedInner }, ctx);
-            // Note: proof may be undefined if proveNarrowing failed (diagnostic pushed)
-            // We still return the expression but without proof - emitter will fail if it sees this
-            return {
-                ...expr,
-                expression: processedInner,
-                proof,
-            };
-        }
-        case "identifier": {
-            // Preserve parameter passing modifiers (out<T>, ref<T>, inref<T>) from `as` casts.
-            // When expression converter processes `value as out<int>`, it creates an identifier
-            // with inferredType: { kind: "referenceType", name: "out", ... }. We must NOT
-            // overwrite this with the numeric proof, as it would lose the cast information.
-            if (expr.inferredType?.kind === "referenceType" &&
-                (expr.inferredType.name === "out" ||
-                    expr.inferredType.name === "ref" ||
-                    expr.inferredType.name === "inref")) {
-                return expr;
-            }
-            // Annotate identifiers with their proven numeric kind
-            // This allows the emitter to know that x is Int32 when used in binary expressions
-            const varKind = ctx.provenVariables.get(expr.name);
-            const paramKind = ctx.provenParameters.get(expr.name);
-            const numericKind = varKind ?? paramKind;
-            if (numericKind !== undefined) {
-                // Update inferredType to reflect the proven numeric type
-                // INVARIANT: "Int32" → primitiveType(name="int")
-                const baseType = numericKind === "Int32"
-                    ? { kind: "primitiveType", name: "int" }
-                    : { kind: "referenceType", name: numericKind };
-                // Preserve nullable wrapper: if the original type was `T | null` or
-                // `T | undefined`, the proven type must remain nullable so that the
-                // emitter does not treat it as a non-nullable value type and drop `??`.
-                const originalIsNullable = expr.inferredType?.kind === "unionType" &&
-                    expr.inferredType.types.some((t) => t.kind === "primitiveType" &&
-                        (t.name === "null" || t.name === "undefined"));
-                const inferredType = originalIsNullable
-                    ? {
-                        kind: "unionType",
-                        types: [
-                            baseType,
-                            { kind: "primitiveType", name: "null" },
-                        ],
-                    }
-                    : baseType;
-                return {
-                    ...expr,
-                    inferredType,
-                };
-            }
-            return expr;
-        }
-        case "array":
-            return {
-                ...expr,
-                elements: expr.elements.map((e) => e !== undefined ? processExpression(e, ctx) : undefined),
-            };
-        case "object":
-            return {
-                ...expr,
-                properties: expr.properties.map((p) => {
-                    if (p.kind === "property") {
-                        return {
-                            ...p,
-                            key: typeof p.key === "string"
-                                ? p.key
-                                : processExpression(p.key, ctx),
-                            value: processExpression(p.value, ctx),
-                        };
-                    }
-                    return {
-                        ...p,
-                        expression: processExpression(p.expression, ctx),
-                    };
-                }),
-            };
-        case "binary": {
-            const processedLeft = processExpression(expr.left, ctx);
-            const processedRight = processExpression(expr.right, ctx);
-            // Comparison operators return boolean, not numeric - skip numeric annotation
-            const comparisonOperators = new Set([
-                "<",
-                ">",
-                "<=",
-                ">=",
-                "==",
-                "!=",
-                "===",
-                "!==",
-            ]);
-            if (comparisonOperators.has(expr.operator)) {
-                // Comparison operators produce boolean, NOT numeric types
-                return {
-                    ...expr,
-                    left: processedLeft,
-                    right: processedRight,
-                };
-            }
-            // Infer numeric kind from processed operands (only for arithmetic/bitwise ops)
-            const leftKind = inferNumericKind(processedLeft, ctx);
-            const rightKind = inferNumericKind(processedRight, ctx);
-            // If both operands have numeric kinds, annotate the binary result
-            if (leftKind !== undefined && rightKind !== undefined) {
-                const resultKind = getBinaryResultKind(leftKind, rightKind);
-                // INVARIANT: "Int32" → primitiveType(name="int")
-                const inferredType = resultKind === "Int32"
-                    ? { kind: "primitiveType", name: "int" }
-                    : { kind: "referenceType", name: resultKind };
-                return {
-                    ...expr,
-                    left: processedLeft,
-                    right: processedRight,
-                    inferredType,
-                };
-            }
-            return {
-                ...expr,
-                left: processedLeft,
-                right: processedRight,
-            };
-        }
-        case "logical":
-            return {
-                ...expr,
-                left: processExpression(expr.left, ctx),
-                right: processExpression(expr.right, ctx),
-            };
-        case "unary":
-        case "update":
-        case "await":
-        case "spread":
-            return {
-                ...expr,
-                expression: processExpression(expr.expression, ctx),
-            };
-        case "yield":
-            return {
-                ...expr,
-                expression: expr.expression
-                    ? processExpression(expr.expression, ctx)
-                    : undefined,
-            };
-        case "conditional":
-            return {
-                ...expr,
-                condition: processExpression(expr.condition, ctx),
-                whenTrue: processExpression(expr.whenTrue, ctx),
-                whenFalse: processExpression(expr.whenFalse, ctx),
-            };
-        case "assignment":
-            return {
-                ...expr,
-                left: expr.left.kind === "identifierPattern" ||
-                    expr.left.kind === "arrayPattern" ||
-                    expr.left.kind === "objectPattern"
-                    ? expr.left
-                    : processExpression(expr.left, ctx),
-                right: processExpression(expr.right, ctx),
-            };
-        case "memberAccess": {
-            const processedObject = processExpression(expr.object, ctx);
-            const processedProperty = typeof expr.property === "string"
-                ? expr.property
-                : processExpression(expr.property, ctx);
-            // ============================================================================
-            // CONTRACT: Proof pass is the ONLY source of numeric proofs.
-            // The emitter ONLY consumes markers (numericIntent); it never re-derives proofs.
-            // If this pass doesn't annotate an index, the emitter will ICE.
-            // ============================================================================
-            // ARRAY INDEX VALIDATION: Use accessKind tag (set during IR build) to determine
-            // whether Int32 proof is required. This is COMPILER-GRADE: no heuristic name matching.
-            if (typeof processedProperty !== "string" && expr.isComputed) {
-                const accessKind = expr.accessKind;
-                // HARD GATE: accessKind MUST be set for computed access.
-                // If missing or "unknown", this is a compiler bug - fail early with clear diagnostic.
-                if (accessKind === undefined || accessKind === "unknown") {
-                    // Build debug info for diagnosis
-                    const objectType = processedObject.inferredType;
-                    const typeInfo = objectType
-                        ? `objectType.kind=${objectType.kind}` +
-                            (objectType.kind === "referenceType"
-                                ? `, name=${objectType.name}, resolvedClrType=${objectType.resolvedClrType ?? "undefined"}`
-                                : "")
-                        : "objectType=undefined";
-                    ctx.diagnostics.push(createDiagnostic("TSN5109", "error", `Computed access kind was not classified during IR build (accessKind=${accessKind ?? "undefined"}, ${typeInfo})`, expr.sourceSpan ??
-                        processedProperty.sourceSpan ??
-                        moduleLocation(ctx), "This is a compiler bug: cannot validate index proof without access classification. " +
-                        "Report this issue with the source code that triggered it."));
-                    // Return without annotation - emitter will ICE if it reaches this
-                    return {
-                        ...expr,
-                        object: processedObject,
-                        property: processedProperty,
-                    };
-                }
-                // Require Int32 proof for:
-                // - clrIndexer: CLR collection indexers (List<T>, Array, etc.)
-                // - stringChar: string character access
-                // Dictionary access does NOT require Int32 proof (key is typed K, usually string)
-                const requiresInt32 = accessKind === "clrIndexer" || accessKind === "stringChar";
-                if (requiresInt32) {
-                    const indexKind = inferNumericKind(processedProperty, ctx);
-                    if (indexKind !== "Int32") {
-                        ctx.diagnostics.push(createDiagnostic("TSN5107", "error", `Array index must be Int32, got ${indexKind ?? "unknown"}`, processedProperty.sourceSpan ?? moduleLocation(ctx), "Use 'index as int' to narrow, or ensure index is derived from Int32 source."));
-                        // Return without annotation - emitter will ICE if it reaches this
-                        return {
-                            ...expr,
-                            object: processedObject,
-                            property: processedProperty,
-                        };
-                    }
-                    // Annotate the index expression with int type so emitter can check it
-                    // without re-deriving the proof. This is the ONLY place proof markers should be set.
-                    // INVARIANT: Array indices must be primitiveType(name="int")
-                    const annotatedProperty = {
-                        ...processedProperty,
-                        inferredType: {
-                            kind: "primitiveType",
-                            name: "int",
-                        },
-                    };
-                    return {
-                        ...expr,
-                        object: processedObject,
-                        property: annotatedProperty,
-                    };
-                }
-                // For dictionary access (accessKind === "dictionary"): no Int32 requirement
-                // Pass through without annotation - key type is handled by the dictionary itself
-            }
-            return {
-                ...expr,
-                object: processedObject,
-                property: processedProperty,
-            };
-        }
-        case "call":
-            return {
-                ...expr,
-                callee: processExpression(expr.callee, ctx),
-                arguments: expr.arguments.map((a) => processExpression(a, ctx)),
-                dynamicImportNamespace: expr.dynamicImportNamespace
-                    ? processExpression(expr.dynamicImportNamespace, ctx)
-                    : undefined,
-            };
-        case "new":
-            return {
-                ...expr,
-                callee: processExpression(expr.callee, ctx),
-                arguments: expr.arguments.map((a) => processExpression(a, ctx)),
-            };
-        case "stackalloc":
-            return {
-                ...expr,
-                size: processExpression(expr.size, ctx),
-            };
-        case "defaultof":
-            return expr;
-        case "templateLiteral":
-            return {
-                ...expr,
-                expressions: expr.expressions.map((e) => processExpression(e, ctx)),
-            };
-        case "arrowFunction": {
-            // Create context with arrow function parameters proven
-            const arrowCtx = {
-                ...ctx,
-                provenParameters: new Map(ctx.provenParameters),
-                provenVariables: new Map(ctx.provenVariables),
-            };
-            for (const param of expr.parameters) {
-                if (param.pattern.kind === "identifierPattern") {
-                    const numericKind = getNumericKindFromType(param.type);
-                    if (numericKind !== undefined) {
-                        arrowCtx.provenParameters.set(param.pattern.name, numericKind);
-                    }
-                }
-            }
-            return {
-                ...expr,
-                body: expr.body.kind === "blockStatement"
-                    ? processStatement(expr.body, arrowCtx)
-                    : processExpression(expr.body, arrowCtx),
-            };
-        }
-        case "functionExpression": {
-            // Create context with function expression parameters proven
-            const funcCtx = {
-                ...ctx,
-                provenParameters: new Map(ctx.provenParameters),
-                provenVariables: new Map(ctx.provenVariables),
-            };
-            for (const param of expr.parameters) {
-                if (param.pattern.kind === "identifierPattern") {
-                    const numericKind = getNumericKindFromType(param.type);
-                    if (numericKind !== undefined) {
-                        funcCtx.provenParameters.set(param.pattern.name, numericKind);
-                    }
-                }
-            }
-            return {
-                ...expr,
-                body: processStatement(expr.body, funcCtx),
-            };
-        }
-        default:
-            return expr;
-    }
-};
-/**
- * Process a statement, proving numeric narrowings in expressions.
- */
-const processStatement = (stmt, ctx) => {
-    switch (stmt.kind) {
-        case "variableDeclaration": {
-            const processedDeclarations = stmt.declarations.map((d) => {
-                const processedInit = d.initializer
-                    ? processExpression(d.initializer, ctx)
-                    : undefined;
-                // Track proven variables from declarations with known numeric kind
-                // This includes:
-                // 0. Explicit type annotations (authoritative)
-                // 1. numericNarrowing with proof (explicit `as int`)
-                // 2. Binary/unary expressions that produce known numeric kinds
-                // 3. Identifiers with known numeric types
-                // We track both const and let (let can be reassigned, but at init we know the type)
-                if (d.name.kind === "identifierPattern") {
-                    // If a variable has an explicit numeric type annotation, that type is authoritative.
-                    // We must not "re-prove" it from the initializer, or we'll incorrectly treat
-                    // `let x: long = 1;` as Int32 (because `1` is an Int32 literal by lexeme).
-                    const declaredKind = getNumericKindFromType(d.type);
-                    if (declaredKind !== undefined) {
-                        ctx.provenVariables.set(d.name.name, declaredKind);
-                    }
-                    else if (d.type === undefined && processedInit !== undefined) {
-                        // First check for explicit numericNarrowing
-                        if (processedInit.kind === "numericNarrowing" &&
-                            processedInit.proof !== undefined) {
-                            ctx.provenVariables.set(d.name.name, processedInit.proof.kind);
-                        }
-                        else {
-                            // Otherwise, try to infer the numeric kind from the expression
-                            const inferredKind = inferNumericKind(processedInit, ctx);
-                            if (inferredKind !== undefined) {
-                                ctx.provenVariables.set(d.name.name, inferredKind);
-                            }
-                        }
-                    }
-                }
-                return {
-                    ...d,
-                    initializer: processedInit,
-                };
-            });
-            return { ...stmt, declarations: processedDeclarations };
-        }
-        case "functionDeclaration": {
-            const paramCtx = {
-                ...ctx,
-                provenParameters: new Map(ctx.provenParameters),
-                provenVariables: new Map(ctx.provenVariables),
-            };
-            for (const param of stmt.parameters) {
-                if (param.pattern.kind === "identifierPattern") {
-                    const numericKind = getNumericKindFromType(param.type);
-                    if (numericKind !== undefined) {
-                        paramCtx.provenParameters.set(param.pattern.name, numericKind);
-                    }
-                }
-            }
-            return {
-                ...stmt,
-                body: processStatement(stmt.body, paramCtx),
-            };
-        }
-        case "classDeclaration": {
-            const processedMembers = stmt.members.map((m) => {
-                if (m.kind === "methodDeclaration" && m.body) {
-                    const methodCtx = {
-                        ...ctx,
-                        provenParameters: new Map(ctx.provenParameters),
-                        provenVariables: new Map(ctx.provenVariables),
-                    };
-                    for (const param of m.parameters) {
-                        if (param.pattern.kind === "identifierPattern") {
-                            const numericKind = getNumericKindFromType(param.type);
-                            if (numericKind !== undefined) {
-                                methodCtx.provenParameters.set(param.pattern.name, numericKind);
-                            }
-                        }
-                    }
-                    return { ...m, body: processStatement(m.body, methodCtx) };
-                }
-                if (m.kind === "propertyDeclaration" && m.initializer) {
-                    return { ...m, initializer: processExpression(m.initializer, ctx) };
-                }
-                if (m.kind === "constructorDeclaration" && m.body) {
-                    return { ...m, body: processStatement(m.body, ctx) };
-                }
-                return m;
-            });
-            return { ...stmt, members: processedMembers };
-        }
-        case "expressionStatement":
-            return {
-                ...stmt,
-                expression: processExpression(stmt.expression, ctx),
-            };
-        case "returnStatement":
-            return {
-                ...stmt,
-                expression: stmt.expression
-                    ? processExpression(stmt.expression, ctx)
-                    : undefined,
-            };
-        case "ifStatement":
-            const processedCondition = processExpression(stmt.condition, ctx);
-            const thenCtx = withInt32ProofsFromTruthyCondition(cloneProofContext(ctx), processedCondition);
-            return {
-                ...stmt,
-                condition: processedCondition,
-                thenStatement: processStatement(stmt.thenStatement, thenCtx),
-                elseStatement: stmt.elseStatement
-                    ? processStatement(stmt.elseStatement, ctx)
-                    : undefined,
-            };
-        case "whileStatement":
-            return {
-                ...stmt,
-                condition: processExpression(stmt.condition, ctx),
-                body: processStatement(stmt.body, ctx),
-            };
-        case "forStatement":
-            return {
-                ...stmt,
-                initializer: stmt.initializer
-                    ? stmt.initializer.kind === "variableDeclaration"
-                        ? processStatement(stmt.initializer, ctx)
-                        : processExpression(stmt.initializer, ctx)
-                    : undefined,
-                condition: stmt.condition
-                    ? processExpression(stmt.condition, ctx)
-                    : undefined,
-                update: stmt.update ? processExpression(stmt.update, ctx) : undefined,
-                body: processStatement(stmt.body, ctx),
-            };
-        case "forOfStatement":
-            return {
-                ...stmt,
-                expression: processExpression(stmt.expression, ctx),
-                body: processStatement(stmt.body, ctx),
-            };
-        case "forInStatement":
-            return {
-                ...stmt,
-                expression: processExpression(stmt.expression, ctx),
-                body: processStatement(stmt.body, ctx),
-            };
-        case "switchStatement":
-            return {
-                ...stmt,
-                expression: processExpression(stmt.expression, ctx),
-                cases: stmt.cases.map((c) => ({
-                    ...c,
-                    test: c.test ? processExpression(c.test, ctx) : undefined,
-                    statements: c.statements.map((s) => processStatement(s, ctx)),
-                })),
-            };
-        case "throwStatement":
-            return {
-                ...stmt,
-                expression: processExpression(stmt.expression, ctx),
-            };
-        case "tryStatement":
-            return {
-                ...stmt,
-                tryBlock: processStatement(stmt.tryBlock, ctx),
-                catchClause: stmt.catchClause
-                    ? {
-                        ...stmt.catchClause,
-                        body: processStatement(stmt.catchClause.body, ctx),
-                    }
-                    : undefined,
-                finallyBlock: stmt.finallyBlock
-                    ? processStatement(stmt.finallyBlock, ctx)
-                    : undefined,
-            };
-        case "blockStatement":
-            return {
-                ...stmt,
-                statements: stmt.statements.map((s) => processStatement(s, ctx)),
-            };
-        case "yieldStatement":
-            return {
-                ...stmt,
-                output: stmt.output ? processExpression(stmt.output, ctx) : undefined,
-            };
-        case "generatorReturnStatement":
-            return {
-                ...stmt,
-                expression: stmt.expression
-                    ? processExpression(stmt.expression, ctx)
-                    : undefined,
-            };
-        default:
-            return stmt;
-    }
-};
-/**
- * Run numeric proof pass on a module.
- */
-const processModule = (module) => {
-    const ctx = {
-        filePath: module.filePath,
-        diagnostics: [],
-        provenVariables: new Map(),
-        provenParameters: new Map(),
-    };
-    const processedBody = module.body.map((stmt) => processStatement(stmt, ctx));
-    const processedExports = module.exports.map((exp) => {
-        if (exp.kind === "default") {
-            return { ...exp, expression: processExpression(exp.expression, ctx) };
-        }
-        if (exp.kind === "declaration") {
-            return { ...exp, declaration: processStatement(exp.declaration, ctx) };
-        }
-        return exp;
-    });
-    return {
-        ok: ctx.diagnostics.length === 0,
-        module: {
-            ...module,
-            body: processedBody,
-            exports: processedExports,
-        },
-        diagnostics: ctx.diagnostics,
-    };
-};
-/**
- * Run numeric proof validation on all modules.
- *
- * HARD GATE: If any diagnostics are returned, the emitter MUST NOT run.
- * This is not a warning system - unprovable narrowings are compilation errors.
- */
-export const runNumericProofPass = (modules) => {
-    const processedModules = [];
-    const allDiagnostics = [];
-    for (const module of modules) {
-        const result = processModule(module);
-        processedModules.push(result.module);
-        allDiagnostics.push(...result.diagnostics);
-    }
-    return {
-        ok: allDiagnostics.length === 0,
-        modules: processedModules,
-        diagnostics: allDiagnostics,
-    };
-};
+export { runNumericProofPass, } from "./numeric-proof-walk.js";
 //# sourceMappingURL=numeric-proof-pass.js.map