@tsonic/emitter 0.0.74 → 0.0.75

package/dist/statements/control/conditionals/guard-analysis.js

@@ -1,767 +1,12 @@
 /**
  * Guard analysis and type narrowing helpers for conditional statements.
  *
- * Contains the 5 guard types (GuardInfo, InstanceofGuardInfo, InGuardInfo,
- * DiscriminantEqualityGuardInfo, NullableGuardInfo) and all detection/analysis
- * helper functions used by the if-statement emitter.
- */
-import { emitExpressionAst } from "../../../expression-emitter.js";
-import { emitIdentifier } from "../../../expressions/identifiers.js";
-import { emitTypeAst } from "../../../type-emitter.js";
-import { extractCalleeNameFromAst } from "../../../core/format/backend-ast/utils.js";
-/**
- * Extract the identifier string from an expression AST that is known to be
- * an identifierExpression. Falls back to extractCalleeNameFromAst for other shapes.
- */
-const extractIdentifierText = (ast) => extractCalleeNameFromAst(ast);
-import { hasDeterministicPropertyMembership, resolveTypeAlias, stripNullish, findUnionMemberIndex, getPropertyType, isDefinitelyValueType, } from "../../../core/semantic/type-resolution.js";
-import { escapeCSharpIdentifier } from "../../../emitter-types/index.js";
-import { emitRemappedLocalName } from "../../../core/format/local-names.js";
-/**
- * Check if a local nominal type (class/interface) has a property with the given TS name.
- */
-const getGuardPropertyType = (type, propertyName, context) => {
-    if (type.kind === "objectType") {
-        const prop = type.members.find((member) => member.kind === "propertySignature" && member.name === propertyName);
-        return prop?.type;
-    }
-    if (type.kind === "referenceType") {
-        if (type.structuralMembers?.length) {
-            const prop = type.structuralMembers.find((member) => member.kind === "propertySignature" && member.name === propertyName);
-            if (prop)
-                return prop.type;
-        }
-        const localTypes = resolveLocalTypesForReference(type, context);
-        if (localTypes) {
-            const lookupName = type.name.includes(".")
-                ? (type.name.split(".").pop() ?? type.name)
-                : type.name;
-            const localPropType = getPropertyType({ ...type, name: lookupName }, propertyName, { ...context, localTypes });
-            if (localPropType)
-                return localPropType;
-        }
-        const resolvedPropType = getPropertyType(type, propertyName, context);
-        if (resolvedPropType)
-            return resolvedPropType;
-    }
-    return undefined;
-};
-/**
- * Resolve a reference type's LocalTypeInfo map (possibly from a different module).
- *
- * This is required for airplane-grade narrowing features that depend on member *types*
- * (not just member names), e.g. discriminant literal equality checks.
- */
-const resolveLocalTypesForReference = (type, context) => {
-    const lookupName = type.name.includes(".")
-        ? (type.name.split(".").pop() ?? type.name)
-        : type.name;
-    if (context.localTypes?.has(lookupName)) {
-        return context.localTypes;
-    }
-    const moduleMap = context.options.moduleMap;
-    if (!moduleMap)
-        return undefined;
-    const matches = [];
-    for (const m of moduleMap.values()) {
-        if (!m.localTypes)
-            continue;
-        if (m.localTypes.has(lookupName)) {
-            matches.push({
-                namespace: m.namespace,
-                localTypes: m.localTypes,
-            });
-        }
-    }
-    if (matches.length === 0)
-        return undefined;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    if (matches.length === 1)
-        return matches[0].localTypes;
-    // Disambiguate by CLR FQN when available.
-    const fqn = type.resolvedClrType ?? (type.name.includes(".") ? type.name : undefined);
-    if (fqn && fqn.includes(".")) {
-        const lastDot = fqn.lastIndexOf(".");
-        const ns = fqn.slice(0, lastDot);
-        const filtered = matches.filter((m) => m.namespace === ns);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        if (filtered.length === 1)
-            return filtered[0].localTypes;
-    }
-    // Ambiguous: refuse to guess.
-    return undefined;
-};
-/**
- * Extract the set of allowed discriminant literal values from a type.
- *
- * Airplane-grade rule:
- * - The discriminant property must be typed as a literal or a union of literals.
- * - If it includes any non-literal members (including null/undefined), we refuse to treat
- *   it as a discriminant for equality-guard narrowing.
- */
-const tryGetLiteralSet = (type, context) => {
-    const resolved = resolveTypeAlias(type, context);
-    if (resolved.kind === "literalType") {
-        return new Set([resolved.value]);
-    }
-    if (resolved.kind === "unionType") {
-        const out = new Set();
-        for (const t of resolved.types) {
-            const r = resolveTypeAlias(t, context);
-            if (r.kind !== "literalType")
-                return undefined;
-            out.add(r.value);
-        }
-        return out;
-    }
-    return undefined;
-};
-const isClrUnionName = (name) => /^Union_[2-8]$/.test(name) || name === "Union" || name.endsWith(".Union");
-const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
-const extractUnionMembers = (type, context) => {
-    const resolvedBase = resolveTypeAlias(stripNullish(type), context);
-    const resolved = resolvedBase.kind === "intersectionType"
-        ? (resolvedBase.types.find((member) => member.kind === "referenceType" && isClrUnionName(member.name)) ?? resolvedBase)
-        : resolvedBase;
-    if (resolved.kind === "unionType") {
-        return resolved.types;
-    }
-    if (resolved.kind === "referenceType" &&
-        isClrUnionName(resolved.name) &&
-        resolved.typeArguments &&
-        resolved.typeArguments.length >= 2 &&
-        resolved.typeArguments.length <= 8) {
-        return resolved.typeArguments;
-    }
-    return undefined;
-};
-const resolveRuntimeUnionFrame = (originalName, unionSourceType, context) => {
-    const members = extractUnionMembers(unionSourceType, context);
-    if (!members)
-        return undefined;
-    const narrowed = context.narrowedBindings?.get(originalName);
-    if (!narrowed) {
-        return {
-            members,
-            candidateMemberNs: members.map((_, index) => index + 1),
-            runtimeUnionArity: members.length,
-        };
-    }
-    if (narrowed.kind !== "runtimeSubset") {
-        return undefined;
-    }
-    if (narrowed.runtimeMemberNs.length !== members.length) {
-        return undefined;
-    }
-    return {
-        members,
-        candidateMemberNs: [...narrowed.runtimeMemberNs],
-        runtimeUnionArity: narrowed.runtimeUnionArity,
-    };
-};
-const buildRenameNarrowedMap = (originalName, narrowedName, memberType, ctxWithId) => {
-    const narrowedMap = new Map(ctxWithId.narrowedBindings ?? []);
-    narrowedMap.set(originalName, {
-        kind: "rename",
-        name: narrowedName,
-        type: memberType,
-    });
-    return narrowedMap;
-};
-const isDefinitelyTruthyLiteral = (value) => {
-    if (typeof value === "string")
-        return value.length > 0;
-    if (typeof value === "number")
-        return value !== 0 && !Number.isNaN(value);
-    return value === true;
-};
-const isDefinitelyFalsyType = (type, context) => {
-    const resolved = resolveTypeAlias(type, context);
-    if (resolved.kind === "literalType") {
-        const value = resolved.value;
-        return value === false || value === 0 || value === "";
-    }
-    if (resolved.kind === "primitiveType") {
-        return resolved.name === "undefined" || resolved.name === "null";
-    }
-    if (resolved.kind === "unionType") {
-        return resolved.types.every((member) => isDefinitelyFalsyType(member, context));
-    }
-    return false;
-};
-const isDefinitelyTruthyType = (type, context) => {
-    const literals = tryGetLiteralSet(type, context);
-    if (literals) {
-        return Array.from(literals).every(isDefinitelyTruthyLiteral);
-    }
-    const resolved = resolveTypeAlias(type, context);
-    if (resolved.kind === "unionType") {
-        return resolved.types.every((member) => isDefinitelyTruthyType(member, context));
-    }
-    return false;
-};
-/**
- * Try to extract guard info from `x.prop === <literal>` or `x.prop !== <literal>`.
- *
- * This supports airplane-grade discriminated union narrowing without relying on
- * TypeScript flow analysis, by mapping the literal to exactly one union member.
- */
-export const tryResolveDiscriminantEqualityGuard = (condition, context) => {
-    // Normalize `!(x.prop === lit)` to `x.prop !== lit` (and vice versa).
-    if (condition.kind === "unary" && condition.operator === "!") {
-        const inner = tryResolveDiscriminantEqualityGuard(condition.expression, context);
-        if (!inner)
-            return undefined;
-        const flipped = inner.operator === "==="
-            ? "!=="
-            : inner.operator === "!=="
-                ? "==="
-                : inner.operator === "=="
-                    ? "!="
-                    : inner.operator === "!="
-                        ? "=="
-                        : inner.operator;
-        return { ...inner, operator: flipped };
-    }
-    if (condition.kind !== "binary")
-        return undefined;
-    if (condition.operator !== "===" &&
-        condition.operator !== "!==" &&
-        condition.operator !== "==" &&
-        condition.operator !== "!=") {
-        return undefined;
-    }
-    const extract = (left, right) => {
-        if (left.kind !== "memberAccess")
-            return undefined;
-        if (left.isOptional)
-            return undefined;
-        if (left.isComputed)
-            return undefined;
-        if (left.object.kind !== "identifier")
-            return undefined;
-        if (typeof left.property !== "string")
-            return undefined;
-        if (right.kind !== "literal")
-            return undefined;
-        if (typeof right.value !== "string" &&
-            typeof right.value !== "number" &&
-            typeof right.value !== "boolean") {
-            return undefined;
-        }
-        return {
-            receiver: left.object,
-            propertyName: left.property,
-            literal: right.value,
-        };
-    };
-    const direct = extract(condition.left, condition.right);
-    const swapped = direct ? undefined : extract(condition.right, condition.left);
-    const match = direct ?? swapped;
-    if (!match)
-        return undefined;
-    const { receiver, propertyName, literal } = match;
-    const originalName = receiver.name;
-    const unionSourceType = receiver.inferredType;
-    if (!unionSourceType)
-        return undefined;
-    const frame = resolveRuntimeUnionFrame(originalName, unionSourceType, context);
-    if (!frame)
-        return undefined;
-    const { members, candidateMemberNs, runtimeUnionArity } = frame;
-    const unionArity = members.length;
-    if (unionArity < 2 || unionArity > 8)
-        return undefined;
-    // Find which union members have a discriminant property type that includes the literal.
-    const matchingIndices = [];
-    const matchingMemberNs = [];
-    for (let i = 0; i < members.length; i++) {
-        const member = members[i];
-        if (!member)
-            continue;
-        const propType = getGuardPropertyType(member, propertyName, context);
-        if (!propType)
-            continue;
-        const literals = tryGetLiteralSet(propType, context);
-        if (!literals)
-            continue;
-        if (literals.has(literal)) {
-            matchingIndices.push(i);
-            matchingMemberNs.push(candidateMemberNs[i] ?? i + 1);
-        }
-    }
-    // Only support the common airplane-grade case: exactly one matching member.
-    if (matchingMemberNs.length !== 1)
-        return undefined;
-    const memberN = matchingMemberNs[0];
-    if (!memberN)
-        return undefined;
-    const matchingIndex = matchingIndices[0];
-    if (matchingIndex === undefined)
-        return undefined;
-    const nextId = (context.tempVarId ?? 0) + 1;
-    const ctxWithId = { ...context, tempVarId: nextId };
-    const narrowedName = `${originalName}__${memberN}_${nextId}`;
-    const escapedOrig = emitRemappedLocalName(originalName, context);
-    const escapedNarrow = escapeCSharpIdentifier(narrowedName);
-    const memberType = members[matchingIndex];
-    if (!memberType)
-        return undefined;
-    const narrowedMap = buildRenameNarrowedMap(originalName, narrowedName, memberType, ctxWithId);
-    return {
-        originalName,
-        propertyName,
-        literal,
-        operator: condition.operator,
-        memberN,
-        unionArity,
-        runtimeUnionArity,
-        candidateMemberNs,
-        candidateMembers: members,
-        ctxWithId,
-        narrowedName,
-        escapedOrig,
-        escapedNarrow,
-        narrowedMap,
-    };
-};
-/**
- * Try to extract guard info from `x.prop` / `!x.prop` where the property acts as a
- * boolean-style discriminant over a runtime union.
- */
-export const tryResolvePropertyTruthinessGuard = (condition, context) => {
-    const extract = (expr) => {
-        if (expr.kind === "unary" && expr.operator === "!") {
-            const inner = extract(expr.expression);
-            return inner ? { ...inner, wantTruthy: !inner.wantTruthy } : undefined;
-        }
-        if (expr.kind !== "memberAccess")
-            return undefined;
-        if (expr.isOptional || expr.isComputed)
-            return undefined;
-        if (expr.object.kind !== "identifier")
-            return undefined;
-        if (typeof expr.property !== "string")
-            return undefined;
-        return {
-            receiver: expr.object,
-            propertyName: expr.property,
-            wantTruthy: true,
-            bindingType: expr.memberBinding?.type,
-            bindingValueTruthiness: expr.inferredType?.kind === "literalType"
-                ? isDefinitelyTruthyLiteral(expr.inferredType.value)
-                : expr.inferredType?.kind === "primitiveType" &&
-                    (expr.inferredType.name === "undefined" ||
-                        expr.inferredType.name === "null")
-                    ? false
-                    : undefined,
-        };
-    };
-    const match = extract(condition);
-    if (!match)
-        return undefined;
-    const { receiver, propertyName, wantTruthy, bindingType, bindingValueTruthiness, } = match;
-    const originalName = receiver.name;
-    const unionSourceType = receiver.inferredType;
-    if (!unionSourceType)
-        return undefined;
-    const frame = resolveRuntimeUnionFrame(originalName, unionSourceType, context);
-    if (!frame)
-        return undefined;
-    const { members, candidateMemberNs, runtimeUnionArity } = frame;
-    const unionArity = members.length;
-    if (unionArity < 2 || unionArity > 8)
-        return undefined;
-    const matchingIndices = [];
-    const matchingMemberNs = [];
-    if (bindingType && bindingValueTruthiness !== undefined) {
-        const bindingTypeName = stripGlobalPrefix(bindingType);
-        const boundMemberIndex = members.findIndex((member) => {
-            if (member?.kind !== "referenceType")
-                return false;
-            const candidateClr = member.resolvedClrType
-                ? stripGlobalPrefix(member.resolvedClrType)
-                : undefined;
-            return (candidateClr === bindingTypeName || member.name === bindingTypeName);
-        });
-        if (boundMemberIndex >= 0) {
-            if (wantTruthy === bindingValueTruthiness) {
-                matchingIndices.push(boundMemberIndex);
-                matchingMemberNs.push(candidateMemberNs[boundMemberIndex] ?? boundMemberIndex + 1);
-            }
-            else if (unionArity === 2) {
-                const otherIndex = boundMemberIndex === 0 ? 1 : 0;
-                matchingIndices.push(otherIndex);
-                matchingMemberNs.push(candidateMemberNs[otherIndex] ?? otherIndex + 1);
-            }
-        }
-    }
-    if (matchingMemberNs.length === 0) {
-        for (let i = 0; i < members.length; i++) {
-            const member = members[i];
-            if (!member)
-                continue;
-            const propType = getGuardPropertyType(member, propertyName, context);
-            if (!propType)
-                continue;
-            const matches = wantTruthy
-                ? isDefinitelyTruthyType(propType, context)
-                : isDefinitelyFalsyType(propType, context);
-            if (matches) {
-                matchingIndices.push(i);
-                matchingMemberNs.push(candidateMemberNs[i] ?? i + 1);
-            }
-        }
-    }
-    if (matchingMemberNs.length !== 1)
-        return undefined;
-    const memberN = matchingMemberNs[0];
-    if (!memberN)
-        return undefined;
-    const matchingIndex = matchingIndices[0];
-    if (matchingIndex === undefined)
-        return undefined;
-    const nextId = (context.tempVarId ?? 0) + 1;
-    const ctxWithId = { ...context, tempVarId: nextId };
-    const narrowedName = `${originalName}__${memberN}_${nextId}`;
-    const escapedOrig = emitRemappedLocalName(originalName, context);
-    const escapedNarrow = escapeCSharpIdentifier(narrowedName);
-    const memberType = members[matchingIndex];
-    if (!memberType)
-        return undefined;
-    const narrowedMap = buildRenameNarrowedMap(originalName, narrowedName, memberType, ctxWithId);
-    return {
-        originalName,
-        propertyName,
-        memberN,
-        unionArity,
-        runtimeUnionArity,
-        candidateMemberNs,
-        candidateMembers: members,
-        ctxWithId,
-        narrowedName,
-        escapedOrig,
-        escapedNarrow,
-        narrowedMap,
-    };
-};
-/**
- * Try to extract guard info from an `("prop" in x)` binary expression.
- */
-export const tryResolveInGuard = (condition, context) => {
-    if (condition.kind !== "binary")
-        return undefined;
-    if (condition.operator !== "in")
-        return undefined;
-    // LHS must be a string literal
-    if (condition.left.kind !== "literal")
-        return undefined;
-    if (typeof condition.left.value !== "string")
-        return undefined;
-    // RHS must be an identifier (the name we can narrow)
-    if (condition.right.kind !== "identifier")
-        return undefined;
-    const propertyName = condition.left.value;
-    const originalName = condition.right.name;
-    const unionSourceType = condition.right.inferredType;
-    if (!unionSourceType)
-        return undefined;
-    const frame = resolveRuntimeUnionFrame(originalName, unionSourceType, context);
-    if (!frame)
-        return undefined;
-    const { members, candidateMemberNs, runtimeUnionArity } = frame;
-    const unionArity = members.length;
-    if (unionArity < 2 || unionArity > 8)
-        return undefined;
-    // Find which union members contain the property.
-    const matchingIndices = [];
-    const matchingMemberNs = [];
-    for (let i = 0; i < members.length; i++) {
-        const member = members[i];
-        if (!member || member.kind !== "referenceType")
-            continue;
-        if (hasDeterministicPropertyMembership(member, propertyName, context) === true) {
-            matchingIndices.push(i);
-            matchingMemberNs.push(candidateMemberNs[i] ?? i + 1);
-        }
-    }
-    // Only support the common "exactly one matching member" narrowing case.
-    if (matchingMemberNs.length !== 1)
-        return undefined;
-    const memberN = matchingMemberNs[0];
-    if (!memberN)
-        return undefined;
-    const matchingIndex = matchingIndices[0];
-    if (matchingIndex === undefined)
-        return undefined;
-    const nextId = (context.tempVarId ?? 0) + 1;
-    const ctxWithId = { ...context, tempVarId: nextId };
-    const narrowedName = `${originalName}__${memberN}_${nextId}`;
-    const [rhsAst] = emitIdentifier(condition.right, context);
-    const escapedOrig = extractIdentifierText(rhsAst);
-    const escapedNarrow = escapeCSharpIdentifier(narrowedName);
-    const memberType = members[matchingIndex];
-    if (!memberType)
-        return undefined;
-    const narrowedMap = buildRenameNarrowedMap(originalName, narrowedName, memberType, ctxWithId);
-    return {
-        originalName,
-        propertyName,
-        memberN,
-        unionArity,
-        runtimeUnionArity,
-        candidateMemberNs,
-        candidateMembers: members,
-        ctxWithId,
-        narrowedName,
-        escapedOrig,
-        escapedNarrow,
-        narrowedMap,
-    };
-};
-/**
- * Conservative check: does a statement definitely terminate control flow?
- * Used to apply post-if narrowing in patterns like:
- *   if (guard(x)) return ...;
- *   // x is now narrowed in the remainder of the block (2-member unions only)
- */
-export const isDefinitelyTerminating = (stmt) => {
-    if (stmt.kind === "returnStatement" || stmt.kind === "throwStatement") {
-        return true;
-    }
-    if (stmt.kind === "blockStatement") {
-        const last = stmt.statements[stmt.statements.length - 1];
-        return last ? isDefinitelyTerminating(last) : false;
-    }
-    return false;
-};
-/**
- * Try to extract guard info from a predicate call expression.
- * Returns GuardInfo if:
- * - call.narrowing is typePredicate
- * - predicate arg is identifier
- * - arg.inferredType resolves to unionType
- * - targetType exists in union
- */
-export const tryResolvePredicateGuard = (call, context) => {
-    const narrowing = call.narrowing;
-    if (!narrowing || narrowing.kind !== "typePredicate")
-        return undefined;
-    const arg = call.arguments[narrowing.argIndex];
-    if (!arg ||
-        ("kind" in arg && arg.kind === "spread") ||
-        arg.kind !== "identifier") {
-        return undefined;
-    }
-    const originalName = arg.name;
-    const unionSourceType = arg.inferredType;
-    if (!unionSourceType)
-        return undefined;
-    const frame = resolveRuntimeUnionFrame(originalName, unionSourceType, context);
-    if (!frame)
-        return undefined;
-    const resolved = {
-        kind: "unionType",
-        types: [...frame.members],
-    };
-    const idx = findUnionMemberIndex(resolved, narrowing.targetType, context);
-    if (idx === undefined)
-        return undefined;
-    const memberN = frame.candidateMemberNs[idx] ?? idx + 1;
-    const unionArity = frame.members.length;
-    const nextId = (context.tempVarId ?? 0) + 1;
-    const ctxWithId = { ...context, tempVarId: nextId };
-    const narrowedName = `${originalName}__${memberN}_${nextId}`;
-    const [argAst] = emitIdentifier(arg, context);
-    const escapedOrig = extractIdentifierText(argAst);
-    const escapedNarrow = escapeCSharpIdentifier(narrowedName);
-    const narrowedMap = buildRenameNarrowedMap(originalName, narrowedName, narrowing.targetType, ctxWithId);
-    return {
-        originalName,
-        targetType: narrowing.targetType,
-        memberN,
-        unionArity,
-        runtimeUnionArity: frame.runtimeUnionArity,
-        candidateMemberNs: frame.candidateMemberNs,
-        candidateMembers: frame.members,
-        ctxWithId,
-        narrowedName,
-        escapedOrig,
-        escapedNarrow,
-        narrowedMap,
-    };
-};
-/**
- * Try to extract guard info from an `instanceof` binary expression.
- * Returns guard info if:
- * - condition is `binary` with operator `instanceof`
- * - lhs is identifier
- *
- * Note: rhs is emitted as a type name (C# pattern).
- */
-export const tryResolveInstanceofGuard = (condition, context) => {
-    if (condition.kind !== "binary")
-        return undefined;
-    if (condition.operator !== "instanceof")
-        return undefined;
-    if (condition.left.kind !== "identifier")
-        return undefined;
-    const originalName = condition.left.name;
-    const [lhsAst, ctxAfterLhs] = emitIdentifier(condition.left, context);
-    const escapedOrig = extractIdentifierText(lhsAst);
-    const nextId = (ctxAfterLhs.tempVarId ?? 0) + 1;
-    const ctxWithId = { ...ctxAfterLhs, tempVarId: nextId };
-    const [rhsAst, rhsCtxAfterExpr] = emitExpressionAst(condition.right, ctxWithId);
-    const inferredRhsType = condition.right.inferredType;
-    let rhsTypeAst;
-    let ctxAfterRhs = rhsCtxAfterExpr;
-    if (rhsAst.kind === "typeReferenceExpression") {
-        rhsTypeAst = rhsAst.type;
-    }
-    else if (inferredRhsType) {
-        const [emittedTypeAst, nextCtx] = emitTypeAst(inferredRhsType, rhsCtxAfterExpr);
-        rhsTypeAst = emittedTypeAst;
-        ctxAfterRhs = nextCtx;
-    }
-    if (!rhsTypeAst) {
-        return undefined;
-    }
-    // Pattern variable name for the narrowed value.
-    const narrowedName = `${originalName}__is_${nextId}`;
-    const escapedNarrow = escapeCSharpIdentifier(narrowedName);
-    const narrowedMap = new Map(ctxAfterRhs.narrowedBindings ?? []);
-    narrowedMap.set(originalName, {
-        kind: "rename",
-        name: narrowedName,
-        type: condition.right.inferredType ?? undefined,
-    });
-    return {
-        originalName,
-        rhsTypeAst,
-        ctxWithId,
-        ctxAfterRhs,
-        narrowedName,
-        escapedOrig,
-        escapedNarrow,
-        narrowedMap,
-        targetType: condition.right.inferredType ?? undefined,
-    };
-};
-/**
- * Check if an expression represents null or undefined.
- * Handles both literal form (from null/undefined keyword) and identifier form
- * (when TypeScript parses "undefined" as an identifier rather than keyword).
- */
-export const isNullOrUndefined = (expr) => {
-    // Literal form: null or undefined keyword
-    if (expr.kind === "literal" &&
-        (expr.value === null || expr.value === undefined)) {
-        return true;
-    }
-    // Identifier form: the identifier "undefined"
-    // (TypeScript sometimes parses undefined as identifier)
-    if (expr.kind === "identifier" && expr.name === "undefined") {
-        return true;
-    }
-    return false;
-};
-export const getMemberAccessNarrowKey = (expr) => {
-    if (expr.isComputed)
-        return undefined;
-    if (typeof expr.property !== "string")
-        return undefined;
-    const obj = expr.object;
-    if (obj.kind === "identifier") {
-        return `${obj.name}.${expr.property}`;
-    }
-    if (obj.kind === "memberAccess") {
-        const prefix = getMemberAccessNarrowKey(obj);
-        return prefix ? `${prefix}.${expr.property}` : undefined;
-    }
-    if (obj.kind === "this") {
-        return `this.${expr.property}`;
-    }
-    return undefined;
-};
-/**
- * Try to extract nullable guard info from a simple comparison expression.
- * This is the core check for patterns like: id !== undefined, id !== null, id != null
- */
-export const tryResolveSimpleNullableGuard = (condition) => {
-    if (condition.kind !== "binary")
-        return undefined;
-    const op = condition.operator;
-    const isNotEqual = op === "!==" || op === "!=";
-    const isEqual = op === "===" || op === "==";
-    if (!isNotEqual && !isEqual)
-        return undefined;
-    // Find operand (identifier or member access) and null/undefined expression
-    let operand;
-    let key;
-    if (isNullOrUndefined(condition.right) &&
-        (condition.left.kind === "identifier" ||
-            condition.left.kind === "memberAccess")) {
-        operand = condition.left;
-    }
-    else if (isNullOrUndefined(condition.left) &&
-        (condition.right.kind === "identifier" ||
-            condition.right.kind === "memberAccess")) {
-        operand = condition.right;
-    }
-    if (!operand)
-        return undefined;
-    if (operand.kind === "identifier") {
-        key = operand.name;
-    }
-    else {
-        key = getMemberAccessNarrowKey(operand);
-    }
-    if (!key)
-        return undefined;
-    const idType = operand.inferredType;
-    if (!idType)
-        return undefined;
-    // Check if type is nullable (has null or undefined in union)
-    const stripped = stripNullish(idType);
-    if (stripped === idType)
-        return undefined; // Not a nullable type
-    // Check if it's a value type that needs .Value
-    const isValueType = isDefinitelyValueType(stripped);
-    return {
-        key,
-        targetExpr: operand,
-        strippedType: stripped,
-        narrowsInThen: isNotEqual,
-        isValueType,
-    };
-};
-/**
- * Try to extract nullable guard info from a condition.
- * Detects patterns like: id !== undefined, id !== null, id != null
- * Also searches inside && (logical AND) conditions recursively.
- *
- * For compound conditions like `method === "GET" && id !== undefined`,
- * we search both sides of the && for a nullable guard pattern.
- *
- * Returns guard info if the condition is a null/undefined check on an identifier
- * with a nullable type that is a value type (needs .Value in C#).
- */
-export const tryResolveNullableGuard = (condition, _context) => {
-    // First try the simple case
-    const simple = tryResolveSimpleNullableGuard(condition);
-    if (simple)
-        return simple;
-    // If this is a && logical expression, search inside it
-    if (condition.kind === "logical" && condition.operator === "&&") {
-        // Check left side
-        const leftGuard = tryResolveNullableGuard(condition.left, _context);
-        if (leftGuard)
-            return leftGuard;
-        // Check right side
-        const rightGuard = tryResolveNullableGuard(condition.right, _context);
-        if (rightGuard)
-            return rightGuard;
-    }
-    return undefined;
-};
+ * Facade module that re-exports all public types and functions from the
+ * split sub-modules:
+ * - guard-types.ts: Guard info types, shared helpers, and utility functions
+ * - guard-detectors.ts: Guard detection/resolution functions (tryResolve*)
+ */
+export { resolveRuntimeUnionFrame, isDefinitelyTerminating, isNullOrUndefined, tryResolveSimpleNullableGuard, tryResolveNullableGuard, } from "./guard-types.js";
+// Guard detection/resolution functions
+export { tryResolveDiscriminantEqualityGuard, tryResolvePropertyTruthinessGuard, tryResolveInGuard, tryResolvePredicateGuard, tryResolveInstanceofGuard, } from "./guard-detectors.js";
 //# sourceMappingURL=guard-analysis.js.map