@tsonic/emitter 0.0.74 → 0.0.75

package/dist/statements/declarations/variables.js

@@ -1,502 +1,88 @@
 /**
- * Variable declaration emission
+ * Variable declaration emission - facade/orchestrator
+ *
+ * Delegates to:
+ * - variable-type-resolution.ts  (type resolution helpers)
+ * - variable-static-arrow.ts     (static arrow field emission)
  */
-import { getAwaitedIrType, NUMERIC_KIND_TO_CSHARP, } from "@tsonic/frontend";
-import { indent, withAsync, withStatic } from "../../types.js";
 import { emitExpressionAst } from "../../expression-emitter.js";
-import { emitBlockStatementAst } from "../../statements/blocks.js";
-import { emitTypeAst } from "../../type-emitter.js";
-import { escapeCSharpIdentifier } from "../../emitter-types/index.js";
-import { resolveBehavioralObjectLiteralType } from "../../expressions/collections.js";
 import { lowerPatternAst, lowerPatternToStaticMembersAst, } from "../../patterns.js";
-import { getIdentifierTypeName } from "../../core/format/backend-ast/utils.js";
+import { resolveEffectiveVariableInitializerType, resolveInitializerEmissionExpectedType, } from "../../core/semantic/variable-type-resolution.js";
 import { allocateLocalName, registerLocalName, } from "../../core/format/local-names.js";
-import { isDefinitelyValueType, resolveTypeAlias, stripNullish, } from "../../core/semantic/type-resolution.js";
+import { registerVariableSymbolTypes } from "../../core/semantic/symbol-types.js";
 import { emitCSharpName } from "../../naming-policy.js";
-import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
-import { identifierExpression, identifierType, } from "../../core/format/backend-ast/builders.js";
-const getAsyncBodyReturnType = (isAsync, returnType) => {
-    if (!isAsync || !returnType)
-        return returnType;
-    return getAwaitedIrType(returnType) ?? returnType;
-};
-/**
- * Types that require explicit LHS type because C# has no literal suffix for them.
- * For these types, `var x = 200;` would infer `int`, not the intended type.
- */
-const TYPES_NEEDING_EXPLICIT_DECL = new Set([
-    "byte",
-    "sbyte",
-    "short",
-    "ushort",
-]);
-/**
- * Check if a type can be explicitly emitted as a C# type.
- * Returns false for types that cannot be named in C# (any, unknown, anonymous).
- */
-const canEmitTypeExplicitly = (type) => {
-    // Reject any/unknown (these are separate type kinds, not primitive names)
-    if (type.kind === "anyType" || type.kind === "unknownType") {
-        return false;
-    }
-    // Accept primitives
-    if (type.kind === "primitiveType") {
-        return true;
-    }
-    // Accept arrays, functions, references, tuples, dictionaries
-    if (type.kind === "arrayType" ||
-        type.kind === "functionType" ||
-        type.kind === "referenceType" ||
-        type.kind === "tupleType" ||
-        type.kind === "dictionaryType") {
-        return true;
-    }
-    // Reject anonymous object types (no CLR backing)
-    if (type.kind === "objectType") {
+import { resolveStaticFieldType, shouldEmitReadonlyStaticField, shouldTreatStructuralAssertionAsErased, isExplicitCastLikeAst, shouldForceDeclaredInitializerCast, resolveLocalTypeAst, } from "./variable-type-resolution.js";
+import { emitStaticArrowFieldMembers } from "./variable-static-arrow.js";
+import { resolveIdentifierValueSurfaceType } from "../../core/semantic/direct-value-surfaces.js";
+import { matchesEmittedStorageSurface } from "../../expressions/identifier-storage.js";
+import { resolveDirectStorageExpressionType } from "../../expressions/direct-storage-types.js";
+const hasUnresolvedReferenceLeaves = (type, context) => {
+    if (!type || typeof type !== "object") {
         return false;
     }
-    // Reject unions containing any/unknown
-    if (type.kind === "unionType") {
-        return type.types.every(canEmitTypeExplicitly);
-    }
-    return false;
-};
-/**
- * Check if a type requires explicit local variable declaration.
- * Returns true for types like byte, sbyte, short, ushort that have no C# suffix.
- * Resolves type aliases to get the underlying type.
- */
-const needsExplicitLocalType = (type, context) => {
-    // Resolve aliases (e.g., local type aliases)
-    const resolved = resolveTypeAlias(stripNullish(type), context);
-    // Check primitive types
-    if (resolved.kind === "primitiveType") {
-        return TYPES_NEEDING_EXPLICIT_DECL.has(resolved.name);
-    }
-    // Check reference types - these may be CLR types from @tsonic/core
-    // (byte, sbyte, short, ushort are imported as reference types, not primitives)
-    if (resolved.kind === "referenceType") {
-        return TYPES_NEEDING_EXPLICIT_DECL.has(resolved.name);
-    }
-    return false;
-};
-/**
- * Resolve a C#-emittable runtime type for `asinterface<T>(x)` locals.
- *
- * `T` may be a type alias or an intersection type (e.g. extension-method overlays).
- * We must pick a nominal/runtime constituent that has a CLR representation.
- */
-const resolveAsInterfaceTargetType = (type, context) => {
-    const resolved = resolveTypeAlias(stripNullish(type), context);
-    // Unwrap tsbindgen's `ExtensionMethods<TShape>` wrapper (type-only).
-    if (resolved.kind === "referenceType" && resolved.typeArguments?.length) {
-        const importBinding = context.importBindings?.get(resolved.name);
-        const clrName = importBinding?.kind === "type"
-            ? (getIdentifierTypeName(importBinding.typeAst) ?? "")
-            : "";
-        if (clrName.endsWith(".ExtensionMethods")) {
-            const shape = resolved.typeArguments[0];
-            if (shape)
-                return resolveAsInterfaceTargetType(shape, context);
-        }
-    }
-    if (resolved.kind === "intersectionType") {
-        for (const part of resolved.types) {
-            const candidate = resolveAsInterfaceTargetType(part, context);
-            if (candidate.kind === "referenceType" &&
-                candidate.name.startsWith("__Ext_")) {
-                continue;
-            }
-            if (candidate.kind === "objectType" ||
-                candidate.kind === "intersectionType") {
-                continue;
-            }
-            return candidate;
-        }
-    }
-    return resolved;
-};
-const seedLocalNameMapFromParameters = (params, context) => {
-    const map = new Map(context.localNameMap ?? []);
-    const used = new Set();
-    for (const p of params) {
-        if (p.pattern.kind === "identifierPattern") {
-            const emitted = escapeCSharpIdentifier(p.pattern.name);
-            map.set(p.pattern.name, emitted);
-            used.add(emitted);
-        }
-    }
-    return { ...context, localNameMap: map, usedLocalNames: used };
-};
-/**
- * Resolve the C# type AST for a static field declaration.
- *
- * Priority:
- * 1) numericNarrowing initializer (e.g., `1000 as int`) - use CLR type
- * 2) typeAssertion initializer (e.g., `obj as Person`) - use target type
- * 3) asinterface initializer (e.g., `asinterface<IQueryable<T>>(db.Events)`) - use target type
- * 4) Explicit/inferred IR type
- * 5) Infer from initializer (new, literal, inferredType)
- * 6) Fallback to object
- *
- * Arrow function types are handled separately in emitStaticArrowFieldMembers.
- */
-const resolveStaticFieldType = (decl, context) => {
-    const init = decl.initializer;
-    // numericNarrowing
-    if (init?.kind === "numericNarrowing" && init.targetKind) {
-        const csharpType = NUMERIC_KIND_TO_CSHARP.get(init.targetKind) ?? "double";
-        return [identifierType(csharpType), context];
-    }
-    // typeAssertion
-    if (init?.kind === "typeAssertion" && init.targetType) {
-        return emitTypeAst(init.targetType, context);
-    }
-    // asinterface
-    if (init?.kind === "asinterface" && init.targetType) {
-        const targetType = resolveAsInterfaceTargetType(init.targetType, context);
-        return emitTypeAst(targetType, context);
-    }
-    // Explicit type annotation
-    if (decl.type) {
-        return emitTypeAst(decl.type, context);
-    }
-    // Infer from new expression
-    if (init?.kind === "new") {
-        // Type is inferred from the new expression callee + type args.
-        // We emit the callee as expression AST and construct a type from it.
-        const newExpr = init;
-        const [calleeAst, calleeContext] = emitExpressionAst(newExpr.callee, context);
-        let currentContext = calleeContext;
-        const calleeText = extractCalleeNameFromAst(calleeAst);
-        if (newExpr.typeArguments && newExpr.typeArguments.length > 0) {
-            const typeArgs = [];
-            for (const typeArg of newExpr.typeArguments) {
-                const [typeArgAst, newCtx] = emitTypeAst(typeArg, currentContext);
-                typeArgs.push(typeArgAst);
-                currentContext = newCtx;
+    const record = type;
+    const kind = typeof record.kind === "string" ? record.kind : undefined;
+    switch (kind) {
+        case "referenceType": {
+            if (typeof record.resolvedClrType === "string") {
+                return false;
             }
-            return [identifierType(calleeText, typeArgs), currentContext];
-        }
-        return [identifierType(calleeText), currentContext];
-    }
-    // Infer from literal
-    if (init?.kind === "literal") {
-        const lit = init;
-        if (typeof lit.value === "string") {
-            return [identifierType("string"), context];
-        }
-        if (typeof lit.value === "number") {
-            const csharpType = lit.numericIntent
-                ? (NUMERIC_KIND_TO_CSHARP.get(lit.numericIntent) ?? "double")
-                : "double";
-            return [identifierType(csharpType), context];
-        }
-        if (typeof lit.value === "boolean") {
-            return [identifierType("bool"), context];
-        }
-        return [identifierType("object"), context];
-    }
-    // Infer from initializer's inferred type
-    if (init?.kind === "object") {
-        const behavioralType = resolveBehavioralObjectLiteralType(init, context);
-        if (behavioralType) {
-            return emitTypeAst(behavioralType, context);
-        }
-    }
-    if (init?.inferredType && canEmitTypeExplicitly(init.inferredType)) {
-        return emitTypeAst(init.inferredType, context);
-    }
-    return [identifierType("object"), context];
-};
-const shouldEmitReadonlyStaticField = (stmt, decl, context) => {
-    if (stmt.declarationKind !== "const")
-        return false;
-    if (decl.name.kind !== "identifierPattern")
-        return true;
-    return !(decl.name.name && context.mutableModuleBindings?.has(decl.name.name));
-};
-/**
- * Validate that an arrow function's type parameters are in scope.
- * Throws ICE if an out-of-scope type parameter is found.
- */
-const validateArrowTypeScope = (arrowFunc, arrowReturnType, inScopeTypeParams) => {
-    const findOutOfScopeTypeParam = (type) => {
-        switch (type.kind) {
-            case "typeParameterType":
-                return inScopeTypeParams.has(type.name) ? undefined : type.name;
-            case "arrayType":
-                return findOutOfScopeTypeParam(type.elementType);
-            case "dictionaryType": {
-                const key = findOutOfScopeTypeParam(type.keyType);
-                return key ?? findOutOfScopeTypeParam(type.valueType);
+            const typeIdClrName = record.typeId &&
+                typeof record.typeId === "object" &&
+                typeof record.typeId.clrName === "string";
+            if (typeIdClrName) {
+                return false;
             }
-            case "referenceType":
-                if (type.typeArguments) {
-                    for (const arg of type.typeArguments) {
-                        const hit = findOutOfScopeTypeParam(arg);
-                        if (hit)
-                            return hit;
-                    }
-                }
-                return undefined;
-            case "unionType":
-                for (const t of type.types) {
-                    const hit = findOutOfScopeTypeParam(t);
-                    if (hit)
-                        return hit;
-                }
-                return undefined;
-            case "tupleType":
-                for (const e of type.elementTypes) {
-                    const hit = findOutOfScopeTypeParam(e);
-                    if (hit)
-                        return hit;
-                }
-                return undefined;
-            case "functionType": {
-                for (const p of type.parameters) {
-                    if (!p.type)
-                        continue;
-                    const hit = findOutOfScopeTypeParam(p.type);
-                    if (hit)
-                        return hit;
-                }
-                return type.returnType
-                    ? findOutOfScopeTypeParam(type.returnType)
-                    : undefined;
+            const rawName = typeof record.name === "string" ? record.name : undefined;
+            const lookupName = rawName?.includes(".")
+                ? (rawName.split(".").pop() ?? rawName)
+                : rawName;
+            if ((rawName &&
+                (context.localTypes?.has(rawName) ||
+                    context.importBindings?.has(rawName))) ||
+                (lookupName &&
+                    (context.localTypes?.has(lookupName) ||
+                        context.importBindings?.has(lookupName)))) {
+                return false;
             }
-            default:
-                return undefined;
-        }
-    };
-    for (const param of arrowFunc.parameters) {
-        if (!param.type)
-            continue;
-        const hit = findOutOfScopeTypeParam(param.type);
-        if (hit) {
-            throw new Error(`ICE: Generic function value reached emitter (type parameter '${hit}' is not in scope). Validation should have emitted TSN7432.`);
+            return true;
         }
+        case "arrayType":
+            return hasUnresolvedReferenceLeaves(record.elementType, context);
+        case "dictionaryType":
+            return (hasUnresolvedReferenceLeaves(record.keyType, context) ||
+                hasUnresolvedReferenceLeaves(record.valueType, context));
+        case "tupleType":
+            return Array.isArray(record.elementTypes)
+                ? record.elementTypes.some((elementType) => hasUnresolvedReferenceLeaves(elementType, context))
+                : false;
+        case "unionType":
+        case "intersectionType":
+            return Array.isArray(record.types)
+                ? record.types.some((memberType) => hasUnresolvedReferenceLeaves(memberType, context))
+                : false;
+        case "functionType":
+            return ((Array.isArray(record.parameters)
+                ? record.parameters.some((parameter) => hasUnresolvedReferenceLeaves(parameter && typeof parameter === "object"
+                    ? parameter.type
+                    : undefined, context))
+                : false) || hasUnresolvedReferenceLeaves(record.returnType, context));
+        default:
+            return false;
     }
-    const retHit = findOutOfScopeTypeParam(arrowReturnType);
-    if (retHit) {
-        throw new Error(`ICE: Generic function value reached emitter (type parameter '${retHit}' is not in scope). Validation should have emitted TSN7432.`);
-    }
-};
-/**
- * Resolve the return type for a static arrow function.
- */
-const resolveArrowReturnType = (arrowFunc) => {
-    const result = arrowFunc.returnType ??
-        (arrowFunc.inferredType?.kind === "functionType"
-            ? arrowFunc.inferredType.returnType
-            : undefined);
-    if (!result) {
-        throw new Error("ICE: Arrow function without return type reached emitter - neither explicit nor inferred type available");
-    }
-    return result;
 };
-/**
- * Emit a static arrow function as field + companion __Impl method.
- *
- * Returns:
- * - For optional-arg arrows: [delegate decl, field, __Impl method]
- * - For regular arrows: [field, __Impl method]
- */
-const emitStaticArrowFieldMembers = (stmt, decl, context) => {
-    const arrowFunc = decl.initializer;
-    let currentContext = context;
-    // Resolve and validate return type
-    const arrowReturnType = resolveArrowReturnType(arrowFunc);
-    const inScopeTypeParams = currentContext.typeParameters ?? new Set();
-    validateArrowTypeScope(arrowFunc, arrowReturnType, inScopeTypeParams);
-    // Emit parameter types
-    const paramTypeAsts = [];
-    for (const param of arrowFunc.parameters) {
-        if (param.type) {
-            const [paramTypeAst, newCtx] = emitTypeAst(param.type, currentContext);
-            paramTypeAsts.push(paramTypeAst);
-            currentContext = newCtx;
-        }
-        else {
-            const paramName = param.pattern.kind === "identifierPattern"
-                ? param.pattern.name
-                : "unknown";
-            throw new Error(`ICE: Untyped parameter '${paramName}' reached emitter - validation missed TSN7405`);
-        }
-    }
-    // Emit return type AST
-    const [returnTypeAst, retCtx] = emitTypeAst(arrowReturnType, currentContext);
-    currentContext = retCtx;
-    const members = [];
-    if (decl.name.kind !== "identifierPattern") {
-        throw new Error("ICE: Arrow function value declarations must use identifier bindings.");
-    }
-    const declName = decl.name.name;
-    if (!declName) {
-        throw new Error("ICE: Identifier-pattern variable declaration missing name in static arrow lowering.");
-    }
-    const fieldName = emitCSharpName(declName, "fields", context);
-    const implName = `${fieldName}__Impl`;
-    // Determine field type: delegate, Func<>, or Action<>
-    const needsOptionalArgs = arrowFunc.parameters.some((p) => p.isOptional || !!p.initializer);
-    let fieldTypeAst;
-    if (needsOptionalArgs) {
-        // Custom delegate type for optional parameters
-        const hasInitializer = arrowFunc.parameters.some((p) => !!p.initializer);
-        if (hasInitializer) {
-            throw new Error("ICE: Arrow function values with default parameter initializers are not supported. Use a named function declaration instead.");
-        }
-        if (decl.name.kind !== "identifierPattern") {
-            throw new Error("ICE: Arrow function value with optional params must use an identifier binding.");
-        }
-        const delegateTypeName = `${fieldName}__Delegate`;
-        const access = stmt.isExported ? "public" : "internal";
-        // Build delegate parameter ASTs
-        const delegateParams = [];
-        for (let i = 0; i < arrowFunc.parameters.length; i++) {
-            const param = arrowFunc.parameters[i];
-            if (!param?.type)
-                continue;
-            const pTypeAst = paramTypeAsts[i];
-            if (!pTypeAst) {
-                throw new Error("ICE: Parameter type AST missing while emitting arrow delegate signature.");
-            }
-            const paramName = param.pattern.kind === "identifierPattern"
-                ? escapeCSharpIdentifier(param.pattern.name)
-                : `p${i}`;
-            delegateParams.push({
-                name: paramName,
-                type: param.isOptional
-                    ? { kind: "nullableType", underlyingType: pTypeAst }
-                    : pTypeAst,
-                defaultValue: param.isOptional
-                    ? { kind: "defaultExpression" }
-                    : undefined,
-            });
-        }
-        members.push({
-            kind: "delegateDeclaration",
-            modifiers: [access],
-            returnType: returnTypeAst,
-            name: delegateTypeName,
-            parameters: delegateParams,
-        });
-        fieldTypeAst = identifierType(delegateTypeName);
+const registerConditionAlias = (originalName, declarationKind, initializer, context) => {
+    const nextAliases = new Map(context.conditionAliases ?? []);
+    if (declarationKind === "const" && initializer) {
+        nextAliases.set(originalName, initializer);
     }
     else {
-        // Func<> or Action<>
-        const isVoidReturn = (returnTypeAst.kind === "identifierType" &&
-            returnTypeAst.name === "void") ||
-            (returnTypeAst.kind === "predefinedType" &&
-                returnTypeAst.keyword === "void");
-        if (isVoidReturn) {
-            fieldTypeAst =
-                paramTypeAsts.length === 0
-                    ? identifierType("global::System.Action")
-                    : identifierType("global::System.Action", paramTypeAsts);
-        }
-        else {
-            fieldTypeAst = identifierType("global::System.Func", [
-                ...paramTypeAsts,
-                returnTypeAst,
-            ]);
-        }
-    }
-    // Field: public/internal static FieldType fieldName = implName;
-    const fieldModifiers = [
-        stmt.isExported ? "public" : "internal",
-        "static",
-        ...(shouldEmitReadonlyStaticField(stmt, decl, context) ? ["readonly"] : []),
-    ];
-    members.push({
-        kind: "fieldDeclaration",
-        attributes: [],
-        modifiers: fieldModifiers,
-        type: fieldTypeAst,
-        name: fieldName,
-        initializer: identifierExpression(implName),
-    });
-    // __Impl method: private static ReturnType implName(params) { ... }
-    const methodParams = [];
-    let paramCtx = currentContext;
-    for (let i = 0; i < arrowFunc.parameters.length; i++) {
-        const param = arrowFunc.parameters[i];
-        if (!param?.type)
-            continue;
-        const mTypeAst = paramTypeAsts[i];
-        if (!mTypeAst) {
-            throw new Error("ICE: Parameter type AST missing while emitting arrow implementation method.");
-        }
-        const paramName = param.pattern.kind === "identifierPattern"
-            ? escapeCSharpIdentifier(param.pattern.name)
-            : `p${i}`;
-        methodParams.push({
-            name: paramName,
-            type: param.isOptional
-                ? { kind: "nullableType", underlyingType: mTypeAst }
-                : mTypeAst,
-            defaultValue: param.isOptional
-                ? { kind: "defaultExpression" }
-                : undefined,
-        });
+        nextAliases.delete(originalName);
     }
-    const bodyBaseContext = seedLocalNameMapFromParameters(arrowFunc.parameters, withAsync(withStatic(indent(paramCtx), false), arrowFunc.isAsync));
-    const bodyReturnType = getAsyncBodyReturnType(arrowFunc.isAsync, arrowReturnType);
-    const methodModifiers = [
-        "private",
-        "static",
-        ...(arrowFunc.isAsync ? ["async"] : []),
-    ];
-    // Build method body AST
-    const bodyResult = (() => {
-        if (arrowFunc.body.kind === "blockStatement") {
-            return emitBlockStatementAst(arrowFunc.body, {
-                ...bodyBaseContext,
-                returnType: bodyReturnType,
-            });
-        }
-        const [exprAst, bodyCtx] = emitExpressionAst(arrowFunc.body, bodyBaseContext, bodyReturnType);
-        const isVoidReturn = !bodyReturnType ||
-            bodyReturnType.kind === "voidType" ||
-            (bodyReturnType.kind === "primitiveType" &&
-                bodyReturnType.name === "undefined");
-        const blockAst = {
-            kind: "blockStatement",
-            statements: isVoidReturn
-                ? [{ kind: "expressionStatement", expression: exprAst }]
-                : [{ kind: "returnStatement", expression: exprAst }],
-        };
-        return [blockAst, bodyCtx];
-    })();
-    const bodyAst = bodyResult[0];
-    paramCtx = bodyResult[1];
-    members.push({
-        kind: "methodDeclaration",
-        attributes: [],
-        modifiers: methodModifiers,
-        returnType: returnTypeAst,
-        name: implName,
-        parameters: methodParams,
-        body: bodyAst,
-    });
-    return [
-        members,
-        {
-            ...context,
-            ...paramCtx,
-            indentLevel: context.indentLevel,
-            isStatic: context.isStatic,
-            isAsync: context.isAsync,
-            className: context.className,
-            returnType: context.returnType,
-            typeParameters: context.typeParameters,
-            typeParamConstraints: context.typeParamConstraints,
-            typeParameterNameMap: context.typeParameterNameMap,
-            localNameMap: context.localNameMap,
-            usedLocalNames: context.usedLocalNames,
-        },
-    ];
+    return {
+        ...context,
+        conditionAliases: nextAliases,
+    };
 };
 /**
  * Emit a static variable declaration as AST members (fields, methods, delegates).
@@ -513,13 +99,14 @@ export const emitVariableDeclaration = (stmt, context) => {
             }
             const [initAst, newContext] = emitExpressionAst(decl.initializer, currentContext, decl.type);
             currentContext = newContext;
-            const patternType = decl.type ?? decl.initializer.inferredType;
+            const patternType = decl.type ??
+                resolveEffectiveVariableInitializerType(decl.initializer, currentContext);
             const result = lowerPatternToStaticMembersAst(decl.name, initAst, patternType, currentContext);
             members.push(...result.members);
             currentContext = result.context;
             continue;
         }
-        // Arrow function in static context → field + __Impl method (+ optional delegate)
+        // Arrow function in static context -> field + __Impl method (+ optional delegate)
         if (context.isStatic && decl.initializer?.kind === "arrowFunction") {
             const [arrowMembers, arrowCtx] = emitStaticArrowFieldMembers(stmt, decl, currentContext);
             members.push(...arrowMembers);
@@ -573,6 +160,7 @@ export const emitVariableDeclaration = (stmt, context) => {
             returnType: context.returnType,
             narrowedBindings: context.narrowedBindings,
             voidResolveNames: context.voidResolveNames,
+            promiseResolveValueTypes: context.promiseResolveValueTypes,
             typeParameters: context.typeParameters,
             typeParamConstraints: context.typeParamConstraints,
             typeParameterNameMap: context.typeParameterNameMap,
@@ -581,115 +169,6 @@ export const emitVariableDeclaration = (stmt, context) => {
         },
     ];
 };
-/**
- * Helper: check if an initializer is a nullish expression (undefined/null literal or identifier).
- */
-const isNullishInitializer = (init) => (init.kind === "literal" &&
-    (init.value === undefined ||
-        init.value === null)) ||
-    (init.kind === "identifier" &&
-        (init.name === "undefined" ||
-            init.name === "null"));
-const isNullableValueUnion = (type) => {
-    if (!type || type.kind !== "unionType")
-        return false;
-    const hasNullish = type.types.some((member) => member.kind === "primitiveType" &&
-        (member.name === "undefined" || member.name === "null"));
-    if (!hasNullish)
-        return false;
-    return isDefinitelyValueType(stripNullish(type));
-};
-/**
- * Determine the C# type AST for a local variable declaration.
- *
- * Priority:
- * 1) asinterface initializer - use target type
- * 2) Explicit/inferred IR type (if C#-emittable)
- * 3) Nullish initializer with annotation - use explicit type
- * 4) Nullish initializer without annotation - use inferred or object?
- * 5) Types needing explicit declaration (byte, sbyte, short, ushort)
- * 6) stackalloc - target-typed to produce Span<T>
- * 7) var
- */
-const resolveLocalTypeAst = (decl, context) => {
-    // asinterface<T>(x) - preserve target type in LHS
-    if (!decl.type && decl.initializer?.kind === "asinterface") {
-        const targetType = resolveAsInterfaceTargetType(decl.initializer.targetType, context);
-        return emitTypeAst(targetType, context);
-    }
-    // Explicit TypeScript annotation that is C#-emittable
-    if (decl.type && canEmitTypeExplicitly(decl.type)) {
-        return emitTypeAst(decl.type, context);
-    }
-    // Nullish initializer with explicit annotation → must use explicit type
-    if (decl.type && decl.initializer && isNullishInitializer(decl.initializer)) {
-        return emitTypeAst(decl.type, context);
-    }
-    // Nullish initializer without annotation → use inferred type or object?
-    if (!decl.type &&
-        decl.initializer &&
-        isNullishInitializer(decl.initializer)) {
-        const fallbackType = decl.initializer.inferredType;
-        if (fallbackType && canEmitTypeExplicitly(fallbackType)) {
-            return emitTypeAst(fallbackType, context);
-        }
-        return [
-            {
-                kind: "nullableType",
-                underlyingType: { kind: "predefinedType", keyword: "object" },
-            },
-            context,
-        ];
-    }
-    if (!decl.type &&
-        decl.initializer &&
-        isNullableValueUnion(decl.initializer.inferredType)) {
-        const inferredType = decl.initializer.inferredType;
-        if (inferredType) {
-            return emitTypeAst(inferredType, context);
-        }
-    }
-    if (!decl.type &&
-        (decl.initializer?.kind === "arrowFunction" ||
-            decl.initializer?.kind === "functionExpression")) {
-        const functionInitializer = decl.initializer;
-        const inferredReturnType = functionInitializer.body &&
-            functionInitializer.body.kind !== "blockStatement"
-            ? functionInitializer.body.inferredType
-            : undefined;
-        const resolvedReturnType = functionInitializer.returnType ?? inferredReturnType;
-        const functionType = functionInitializer.inferredType?.kind === "functionType"
-            ? functionInitializer.inferredType
-            : functionInitializer.parameters &&
-                functionInitializer.parameters.every((param) => !!param.type) &&
-                resolvedReturnType
-                ? {
-                    kind: "functionType",
-                    parameters: functionInitializer.parameters,
-                    returnType: resolvedReturnType,
-                }
-                : undefined;
-        if (functionType) {
-            return emitTypeAst(functionType, context);
-        }
-    }
-    // Types that need explicit declaration (byte, sbyte, short, ushort)
-    if (decl.type &&
-        decl.initializer?.kind !== "stackalloc" &&
-        needsExplicitLocalType(decl.type, context)) {
-        return emitTypeAst(decl.type, context);
-    }
-    // stackalloc - must be target-typed to produce Span<T>
-    if (decl.initializer?.kind === "stackalloc") {
-        const targetType = decl.type ?? decl.initializer.inferredType;
-        if (!targetType) {
-            throw new Error("ICE: stackalloc initializer missing target type (no decl.type and no inferredType)");
-        }
-        return emitTypeAst(targetType, context);
-    }
-    // Default: var
-    return [{ kind: "varType" }, context];
-};
 /**
  * Emit a local (non-static) variable declaration as AST.
  *
@@ -710,7 +189,8 @@ export const emitVariableDeclarationAst = (stmt, context) => {
             }
             const [initAst, newContext] = emitExpressionAst(decl.initializer, currentContext, decl.type);
             currentContext = newContext;
-            const patternType = decl.type ?? decl.initializer.inferredType;
+            const patternType = decl.type ??
+                resolveEffectiveVariableInitializerType(decl.initializer, currentContext);
             const result = lowerPatternAst(decl.name, initAst, patternType, currentContext);
             statements.push(...result.statements);
             currentContext = result.context;
@@ -744,6 +224,8 @@ export const emitVariableDeclarationAst = (stmt, context) => {
                     ],
                 });
                 currentContext = registerLocalName(originalName, localName, currentContext);
+                currentContext = registerVariableSymbolTypes(originalName, decl, currentContext);
+                currentContext = registerConditionAlias(originalName, stmt.declarationKind, decl.initializer, currentContext);
                 const expectedInitializerType = decl.type ??
                     (decl.initializer.inferredType?.kind === "functionType"
                         ? decl.initializer.inferredType
@@ -766,10 +248,46 @@ export const emitVariableDeclarationAst = (stmt, context) => {
             }
             // Emit initializer (after allocation, before registration - C# scoping)
             let initAst = undefined;
+            let emittedInitializerStorageType = undefined;
             if (decl.initializer) {
-                const [exprAst, newContext] = emitExpressionAst(decl.initializer, currentContext, decl.type);
+                const expectedInitializerType = shouldTreatStructuralAssertionAsErased(decl, currentContext)
+                    ? undefined
+                    : resolveInitializerEmissionExpectedType(decl.type, decl.initializer, currentContext);
+                const [exprAst, newContext] = emitExpressionAst(decl.initializer, currentContext, expectedInitializerType);
                 currentContext = newContext;
-                initAst = exprAst;
+                const declaredInitializerType = decl.type ??
+                    (decl.initializer.kind === "typeAssertion"
+                        ? decl.initializer.targetType
+                        : resolveEffectiveVariableInitializerType(decl.initializer, currentContext));
+                const storageSurfaceNeedsCast = decl.initializer.kind === "identifier" &&
+                    !!declaredInitializerType &&
+                    !!resolveIdentifierValueSurfaceType(decl.initializer, currentContext) &&
+                    !matchesEmittedStorageSurface(resolveIdentifierValueSurfaceType(decl.initializer, currentContext), declaredInitializerType, currentContext)[0];
+                initAst =
+                    typeAst.kind !== "varType" &&
+                        !isExplicitCastLikeAst(exprAst) &&
+                        (shouldForceDeclaredInitializerCast(decl.initializer, declaredInitializerType, currentContext) ||
+                            storageSurfaceNeedsCast)
+                        ? {
+                            kind: "castExpression",
+                            type: typeAst,
+                            expression: exprAst,
+                        }
+                        : exprAst;
+                emittedInitializerStorageType =
+                    typeAst.kind === "varType"
+                        ? (() => {
+                            const candidateStorageType = resolveDirectStorageExpressionType(decl.initializer, initAst, currentContext);
+                            if (candidateStorageType &&
+                                !hasUnresolvedReferenceLeaves(candidateStorageType, currentContext)) {
+                                return candidateStorageType;
+                            }
+                            return declaredInitializerType &&
+                                !hasUnresolvedReferenceLeaves(declaredInitializerType, currentContext)
+                                ? declaredInitializerType
+                                : undefined;
+                        })()
+                        : undefined;
             }
             else if (typeAst.kind !== "varType") {
                 initAst = {
@@ -779,6 +297,8 @@ export const emitVariableDeclarationAst = (stmt, context) => {
             }
             // Register local name after initializer emission
             currentContext = registerLocalName(originalName, localName, currentContext);
+            currentContext = registerVariableSymbolTypes(originalName, decl, currentContext, emittedInitializerStorageType);
+            currentContext = registerConditionAlias(originalName, stmt.declarationKind, decl.initializer, currentContext);
             statements.push({
                 kind: "localDeclarationStatement",
                 modifiers: [],