@tsonic/emitter 0.0.73 → 0.0.75

package/dist/expressions/access.js

@@ -1,226 +1,31 @@
 /**
- * Member access expression emitters
+ * Member access expression emitters — orchestrator facade.
+ *
+ * Heavy-lifting helpers live in:
+ *   - ./access-resolution.ts  (receiver resolution, reification, member names)
+ *   - ./access-length.ts      (length/count property access helpers)
+ *   - ./access-computed.ts    (computed indexing: dict[key], arr[i], str[i])
+ *   - ./access-property.ts    (non-computed property access: dict.Keys, .length, etc.)
  */
 import { emitExpressionAst } from "../expression-emitter.js";
-import { isExplicitViewProperty, extractInterfaceNameFromView, } from "@tsonic/frontend/types/explicit-views.js";
 import { emitTypeAst } from "../type-emitter.js";
-import { resolveTypeAlias, stripNullish, getAllPropertySignatures, } from "../core/semantic/type-resolution.js";
+import { resolveTypeAlias, stripNullish, getAllPropertySignatures, hasDeterministicPropertyMembership, } from "../core/semantic/type-resolution.js";
 import { emitCSharpName } from "../naming-policy.js";
 import { escapeCSharpIdentifier } from "../emitter-types/index.js";
-import { extractCalleeNameFromAst } from "../core/format/backend-ast/utils.js";
-// ============================================================================
-// CONTRACT: Emitter ONLY consumes proof markers.
-// ============================================================================
-/**
- * Check if an expression has proven Int32 type from the numeric proof pass.
- */
-const hasInt32Proof = (expr) => {
-    if (expr.inferredType?.kind === "primitiveType" &&
-        expr.inferredType.name === "int") {
-        return true;
-    }
-    if (expr.inferredType?.kind === "referenceType" &&
-        expr.inferredType.name === "int") {
-        return true;
-    }
-    return false;
-};
-const bucketFromMemberKind = (kind) => {
-    switch (kind) {
-        case "method":
-            return "methods";
-        case "field":
-            return "fields";
-        case "enumMember":
-            return "enumMembers";
-        default:
-            return "properties";
-    }
-};
-const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
-const stripClrGenericArity = (typeName) => typeName.replace(/`\d+$/, "");
-const createStringLiteralExpression = (value) => ({
-    kind: "literalExpression",
-    text: JSON.stringify(value),
-});
-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;
-    }
-    return undefined;
-};
-const lookupMemberKindFromLocalTypes = (receiverTypeName, memberName, context) => {
-    const local = context.localTypes?.get(receiverTypeName);
-    if (!local)
-        return undefined;
-    if (local.kind === "enum") {
-        return local.members.includes(memberName) ? "enumMember" : undefined;
-    }
-    if (local.kind === "typeAlias") {
-        if (local.type.kind !== "objectType")
-            return undefined;
-        const found = local.type.members.find((m) => m.name === memberName);
-        if (!found)
-            return undefined;
-        return found.kind === "methodSignature" ? "method" : "property";
-    }
-    const members = local.members;
-    for (const m of members) {
-        if (!("name" in m) || m.name !== memberName)
-            continue;
-        if (m.kind === "methodDeclaration" || m.kind === "methodSignature") {
-            return "method";
-        }
-        if (m.kind === "propertySignature")
-            return "property";
-        if (m.kind === "propertyDeclaration") {
-            const hasAccessors = !!(m.getterBody || m.setterBody);
-            return hasAccessors ? "property" : "field";
-        }
-    }
-    return undefined;
-};
-const lookupMemberKindFromIndex = (receiverTypeFqn, memberName, context) => {
-    const perType = context.options.typeMemberIndex?.get(receiverTypeFqn);
-    return perType?.get(memberName);
-};
-const hasPropertyFromBindingsRegistry = (type, propertyName, context) => {
-    const registry = context.bindingsRegistry;
-    if (!registry || registry.size === 0)
-        return undefined;
-    const candidates = new Set();
-    const addCandidate = (value) => {
-        if (!value)
-            return;
-        candidates.add(value);
-        if (value.includes(".")) {
-            const leaf = value.split(".").pop();
-            if (leaf)
-                candidates.add(leaf);
-        }
-    };
-    addCandidate(type.name);
-    addCandidate(type.typeId?.tsName);
-    addCandidate(type.resolvedClrType);
-    addCandidate(type.typeId?.clrName);
-    for (const value of Array.from(candidates)) {
-        if (value.endsWith("$instance")) {
-            candidates.add(value.slice(0, -"$instance".length));
-        }
-        if (value.startsWith("__") && value.endsWith("$views")) {
-            candidates.add(value.slice("__".length, -"$views".length));
-        }
-    }
-    for (const key of candidates) {
-        const binding = registry.get(key);
-        if (!binding)
-            continue;
-        return binding.members.some((member) => member.kind === "property" &&
-            (member.alias === propertyName ||
-                member.name === propertyName ||
-                member.binding.member === propertyName));
-    }
-    return undefined;
-};
-const resolveReceiverTypeFqn = (receiverExpr, receiverType, context) => {
-    if (receiverType?.kind === "referenceType" && receiverType.resolvedClrType) {
-        return receiverType.resolvedClrType;
-    }
-    if (receiverExpr.kind === "identifier") {
-        const binding = context.importBindings?.get(receiverExpr.name);
-        if (binding?.kind === "type") {
-            return stripGlobalPrefix(binding.clrName);
-        }
-    }
-    return undefined;
-};
-const resolveArrayLikeReceiver = (receiverType, context) => {
-    if (!receiverType)
-        return undefined;
-    const resolved = resolveTypeAlias(stripNullish(receiverType), context);
-    if (resolved.kind === "arrayType") {
-        return resolved;
-    }
-    if (resolved.kind === "referenceType" &&
-        (resolved.name === "Array" || resolved.name === "ReadonlyArray") &&
-        resolved.typeArguments &&
-        resolved.typeArguments.length === 1) {
-        const elementType = resolved.typeArguments[0];
-        if (!elementType)
-            return undefined;
-        return {
-            kind: "arrayType",
-            elementType,
-            origin: "explicit",
-        };
-    }
-    return undefined;
-};
-const emitMemberName = (receiverExpr, receiverType, memberName, context, usage) => {
-    if (usage === "call") {
-        return emitCSharpName(memberName, "methods", context);
-    }
-    if (receiverExpr.kind === "identifier") {
-        const binding = context.importBindings?.get(receiverExpr.name);
-        if (binding?.kind === "namespace") {
-            return emitCSharpName(memberName, "fields", context);
-        }
-    }
-    const receiverTypeName = receiverType?.kind === "referenceType" ? receiverType.name : undefined;
-    if (receiverTypeName) {
-        const localKind = lookupMemberKindFromLocalTypes(receiverTypeName, memberName, context);
-        if (localKind) {
-            return emitCSharpName(memberName, bucketFromMemberKind(localKind), context);
-        }
-    }
-    if (receiverExpr.kind === "identifier") {
-        const localKind = lookupMemberKindFromLocalTypes(receiverExpr.name, memberName, context);
-        if (localKind) {
-            return emitCSharpName(memberName, bucketFromMemberKind(localKind), context);
-        }
-    }
-    const receiverFqn = resolveReceiverTypeFqn(receiverExpr, receiverType, context);
-    if (receiverFqn) {
-        const indexedKind = lookupMemberKindFromIndex(receiverFqn, memberName, context);
-        if (indexedKind) {
-            return emitCSharpName(memberName, bucketFromMemberKind(indexedKind), context);
-        }
-    }
-    return emitCSharpName(memberName, "properties", context);
-};
-/**
- * Check if an expression represents a static type reference (not an instance)
- */
-const isStaticTypeReference = (expr, context) => {
-    if (expr.object.kind === "identifier") {
-        const importBinding = context.importBindings?.get(expr.object.name);
-        if (importBinding)
-            return true;
-        if (!expr.object.inferredType)
-            return false;
-    }
-    const objectType = expr.object.inferredType;
-    if (objectType?.kind === "referenceType" ||
-        objectType?.kind === "arrayType" ||
-        objectType?.kind === "intersectionType" ||
-        objectType?.kind === "unionType" ||
-        objectType?.kind === "primitiveType" ||
-        objectType?.kind === "literalType" ||
-        objectType?.kind === "typeParameterType" ||
-        objectType?.kind === "unknownType") {
-        return false;
-    }
-    return true;
-};
+import { identifierExpression } from "../core/format/backend-ast/builders.js";
+import { getIdentifierTypeName, stripNullableTypeAst, } from "../core/format/backend-ast/utils.js";
+import { getMemberAccessNarrowKey } from "../core/semantic/narrowing-keys.js";
+import { buildRuntimeUnionLayout, getRuntimeUnionReferenceMembers, isRuntimeUnionTypeName, } from "../core/semantic/runtime-unions.js";
+import { isSemanticUnion, willCarryAsRuntimeUnion, } from "../core/semantic/union-semantics.js";
+import { resolveIteratorResultReferenceType } from "../core/semantic/structural-resolution.js";
+import { maybeReifyStorageErasedMemberRead, tryEmitMaterializedNarrowedMemberRead, tryEmitStorageCompatibleNarrowedMemberRead, hasPropertyFromBindingsRegistry, resolveEffectiveReceiverType, resolveEmittedReceiverTypeAst, emitMemberName, } from "./access-resolution.js";
+import { isStringReceiverType, tryEmitJsSurfaceArrayLikeLengthAccess, } from "./access-length.js";
+import { tryEmitMemberBindingAccess } from "./access-binding.js";
+import { emitComputedAccess } from "./access-computed.js";
+import { emitPropertyAccess } from "./access-property.js";
+import { materializeDirectNarrowingAst } from "../core/semantic/materialized-narrowing.js";
+import { resolveDirectStorageIrType } from "../core/semantic/direct-storage-ir-types.js";
+import { tryStripConditionalNullishGuardAst } from "../core/semantic/narrowing-builders.js";
 /**
  * Emit a member access expression as CSharpExpressionAst
  */
@@ -234,56 +39,138 @@ export const emitMemberAccess = (expr, context, usage = "value", expectedType) =
         if (narrowed) {
             if (narrowed.kind === "rename") {
                 return [
-                    {
-                        kind: "identifierExpression",
-                        identifier: escapeCSharpIdentifier(narrowed.name),
-                    },
+                    identifierExpression(escapeCSharpIdentifier(narrowed.name)),
                     context,
                 ];
             }
             if (narrowed.kind === "expr") {
-                return [narrowed.exprAst, context];
+                const materializedNarrowed = tryEmitMaterializedNarrowedMemberRead(narrowed, context, expectedType);
+                if (materializedNarrowed) {
+                    return materializedNarrowed;
+                }
+                const storageCompatible = tryEmitStorageCompatibleNarrowedMemberRead(narrowed, expr, context, expectedType);
+                if (storageCompatible) {
+                    return storageCompatible;
+                }
+                return maybeReifyStorageErasedMemberRead(narrowed.exprAst, expr, context, expectedType);
             }
         }
     }
+    const objectType = resolveEffectiveReceiverType(expr.object, context);
+    const propertyName = typeof expr.property === "string" ? expr.property : undefined;
+    if (!expr.isComputed &&
+        usage === "value" &&
+        !expr.isOptional &&
+        (propertyName === "done" || propertyName === "value")) {
+        if ((objectType?.kind === "referenceType" &&
+            objectType.name === "IteratorResult") ||
+            (objectType &&
+                resolveIteratorResultReferenceType(objectType, context) !== undefined)) {
+            const [objectAst, newContext] = emitExpressionAst(expr.object, context);
+            return [
+                {
+                    kind: "memberAccessExpression",
+                    expression: objectAst,
+                    memberName: propertyName,
+                },
+                newContext,
+            ];
+        }
+        const [receiverTypeAst] = resolveEmittedReceiverTypeAst(expr.object, context);
+        const receiverTypeName = receiverTypeAst
+            ? getIdentifierTypeName(stripNullableTypeAst(receiverTypeAst))
+            : undefined;
+        if (receiverTypeName === "global::Tsonic.Runtime.IteratorResult") {
+            const [objectAst, newContext] = emitExpressionAst(expr.object, context);
+            return [
+                {
+                    kind: "memberAccessExpression",
+                    expression: objectAst,
+                    memberName: propertyName,
+                },
+                newContext,
+            ];
+        }
+    }
+    if (!expr.isComputed &&
+        usage === "value" &&
+        context.options.surface === "@tsonic/js" &&
+        isStringReceiverType(objectType, context) &&
+        (expr.property === "length" ||
+            expr.property === "Length")) {
+        const [stringObjectAst, stringContext] = emitExpressionAst(expr.object, context);
+        return [
+            {
+                kind: expr.isOptional
+                    ? "conditionalMemberAccessExpression"
+                    : "memberAccessExpression",
+                expression: stringObjectAst,
+                memberName: "Length",
+            },
+            stringContext,
+        ];
+    }
     // Property access that targets a CLR runtime union
-    if (!expr.isComputed && !expr.isOptional) {
+    if (!expr.isComputed) {
         const prop = expr.property;
-        const objectType = (() => {
-            if (expr.object.kind === "identifier" && context.narrowedBindings) {
-                const narrowed = context.narrowedBindings.get(expr.object.name);
-                if (narrowed?.kind === "rename" && narrowed.type) {
-                    return narrowed.type;
-                }
-                if (narrowed?.kind === "expr") {
-                    return narrowed.type ?? undefined;
-                }
-                if (narrowed?.kind === "runtimeSubset") {
-                    return narrowed.type ?? expr.object.inferredType;
-                }
+        if (objectType &&
+            (isSemanticUnion(objectType, context) ||
+                willCarryAsRuntimeUnion(objectType, context))) {
+            const receiverNarrowKey = expr.object.kind === "identifier"
+                ? expr.object.name
+                : expr.object.kind === "memberAccess"
+                    ? getMemberAccessNarrowKey(expr.object)
+                    : undefined;
+            const receiverNarrowed = receiverNarrowKey
+                ? context.narrowedBindings?.get(receiverNarrowKey)
+                : undefined;
+            const receiverNarrowedType = receiverNarrowed?.kind === "expr" ? receiverNarrowed.type : undefined;
+            if (usage === "value" &&
+                receiverNarrowedType &&
+                !willCarryAsRuntimeUnion(receiverNarrowedType, context) &&
+                hasDeterministicPropertyMembership(receiverNarrowedType, prop, context) === true) {
+                const [objectAst, newContext] = emitExpressionAst(expr.object, context);
+                const receiverStorageType = resolveDirectStorageIrType(expr.object, context);
+                const receiverMaterializationSourceType = receiverNarrowed?.kind === "expr" && receiverNarrowed.type
+                    ? receiverNarrowed.type
+                    : receiverStorageType;
+                const nonNullReceiverAst = tryStripConditionalNullishGuardAst(objectAst) ?? objectAst;
+                const [materializedReceiverAst, materializedReceiverContext] = materializeDirectNarrowingAst(nonNullReceiverAst, receiverMaterializationSourceType, receiverNarrowedType, newContext);
+                const escapedProp = emitMemberName(expr.object, receiverNarrowedType, prop, context, usage);
+                return [
+                    {
+                        kind: expr.isOptional
+                            ? "conditionalMemberAccessExpression"
+                            : "memberAccessExpression",
+                        expression: materializedReceiverAst,
+                        memberName: escapedProp,
+                    },
+                    materializedReceiverContext,
+                ];
             }
-            return expr.object.inferredType;
-        })();
-        if (objectType) {
             const resolvedBase = resolveTypeAlias(stripNullish(objectType), context);
-            const isClrUnionName = (name) => /^Union_[2-8]$/.test(name) ||
-                name === "Union" ||
-                name.endsWith(".Union");
             const resolved = resolvedBase.kind === "intersectionType"
-                ? (resolvedBase.types.find((t) => t.kind === "referenceType" && isClrUnionName(t.name)) ?? resolvedBase)
+                ? (resolvedBase.types.find((t) => t.kind === "referenceType" && isRuntimeUnionTypeName(t.name)) ?? resolvedBase)
                 : resolvedBase;
+            const runtimeReferenceMembers = resolved.kind === "referenceType"
+                ? getRuntimeUnionReferenceMembers(resolved)
+                : undefined;
             const members = resolved.kind === "unionType"
                 ? resolved.types
-                : resolved.kind === "referenceType" &&
-                    isClrUnionName(resolved.name) &&
-                    resolved.typeArguments &&
-                    resolved.typeArguments.length >= 2 &&
-                    resolved.typeArguments.length <= 8
-                    ? resolved.typeArguments
+                : runtimeReferenceMembers
+                    ? runtimeReferenceMembers
                     : [];
-            const arity = members.length;
-            if (arity >= 2 && arity <= 8) {
-                const memberHasProperty = members.map((m) => {
+            const [runtimeLayout] = members.length >= 2
+                ? buildRuntimeUnionLayout(objectType, context, emitTypeAst)
+                : [undefined, context];
+            const runtimeMembers = runtimeLayout?.members ?? members;
+            const arity = runtimeMembers.length;
+            if (arity >= 2) {
+                const memberHasProperty = runtimeMembers.map((m) => {
+                    const deterministic = hasDeterministicPropertyMembership(m, prop, context);
+                    if (deterministic !== undefined) {
+                        return deterministic;
+                    }
                     if (m.kind !== "referenceType")
                         return false;
                     const props = getAllPropertySignatures(m, context);
@@ -298,7 +185,7 @@ export const emitMemberAccess = (expr, context, usage = "value", expectedType) =
                     const escapedProp = emitMemberName(expr.object, objectType, prop, context, usage);
                     if (count === arity) {
                         // All members have the property: use Match lambda
-                        const lambdaArgs = members.map((_, i) => ({
+                        const lambdaArgs = runtimeMembers.map((_, i) => ({
                             kind: "lambdaExpression",
                             isAsync: false,
                             parameters: [{ name: `__m${i + 1}` }],
@@ -315,7 +202,9 @@ export const emitMemberAccess = (expr, context, usage = "value", expectedType) =
                             {
                                 kind: "invocationExpression",
                                 expression: {
-                                    kind: "memberAccessExpression",
+                                    kind: expr.isOptional
+                                        ? "conditionalMemberAccessExpression"
+                                        : "memberAccessExpression",
                                     expression: objectAst,
                                     memberName: "Match",
                                 },
@@ -328,18 +217,23 @@ export const emitMemberAccess = (expr, context, usage = "value", expectedType) =
                     if (armIndex >= 0) {
                         const asMethod = emitCSharpName(`As${armIndex + 1}`, "methods", context);
                         // receiver.AsN().prop
+                        const projectedArmAst = {
+                            kind: "invocationExpression",
+                            expression: {
+                                kind: expr.isOptional
+                                    ? "conditionalMemberAccessExpression"
+                                    : "memberAccessExpression",
+                                expression: objectAst,
+                                memberName: asMethod,
+                            },
+                            arguments: [],
+                        };
                         return [
                             {
-                                kind: "memberAccessExpression",
-                                expression: {
-                                    kind: "invocationExpression",
-                                    expression: {
-                                        kind: "memberAccessExpression",
-                                        expression: objectAst,
-                                        memberName: asMethod,
-                                    },
-                                    arguments: [],
-                                },
+                                kind: expr.isOptional
+                                    ? "conditionalMemberAccessExpression"
+                                    : "memberAccessExpression",
+                                expression: projectedArmAst,
                                 memberName: escapedProp,
                             },
                             newContext,
@@ -349,368 +243,23 @@ export const emitMemberAccess = (expr, context, usage = "value", expectedType) =
             }
         }
     }
-    // Check if this is a hierarchical member binding
-    if (expr.memberBinding) {
-        const { type, member } = expr.memberBinding;
-        const escapedMember = escapeCSharpIdentifier(member);
-        const bindingTypeLeaf = stripClrGenericArity(type).split(".").pop();
-        const receiverType = expr.object.inferredType;
-        const arrayLikeReceiver = resolveArrayLikeReceiver(receiverType, context);
-        if (usage === "value" &&
-            arrayLikeReceiver &&
-            !expr.memberBinding.isExtensionMethod &&
-            !(type === "System.Array" ||
-                type === "global::System.Array" ||
-                type.startsWith("System.Array`") ||
-                type.startsWith("global::System.Array`"))) {
-            const arityText = type.match(/`(\d+)$/)?.[1];
-            const genericArity = arityText ? Number.parseInt(arityText, 10) : 0;
-            if (genericArity <= 1) {
-                const [objectAst, withObject] = emitExpressionAst(expr.object, context);
-                let currentContext = withObject;
-                let wrapperTypeArguments;
-                if (genericArity === 1) {
-                    const [elementTypeAst, withElementType] = emitTypeAst(arrayLikeReceiver.elementType, currentContext);
-                    currentContext = withElementType;
-                    wrapperTypeArguments = [elementTypeAst];
-                }
-                const wrapperAst = {
-                    kind: "objectCreationExpression",
-                    type: {
-                        kind: "identifierType",
-                        name: `global::${stripClrGenericArity(type)}`,
-                        typeArguments: wrapperTypeArguments,
-                    },
-                    arguments: [objectAst],
-                };
-                if (expr.isOptional) {
-                    return [
-                        {
-                            kind: "conditionalMemberAccessExpression",
-                            expression: wrapperAst,
-                            memberName: escapedMember,
-                        },
-                        currentContext,
-                    ];
-                }
-                return [
-                    {
-                        kind: "memberAccessExpression",
-                        expression: wrapperAst,
-                        memberName: escapedMember,
-                    },
-                    currentContext,
-                ];
-            }
-        }
-        if (usage === "value" && expr.memberBinding.isExtensionMethod) {
-            const [objectAst, newContext] = emitExpressionAst(expr.object, context);
-            const extensionCallAst = {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: `global::${type}.${escapedMember}`,
-                },
-                arguments: [objectAst],
-            };
-            if (!expr.isOptional) {
-                return [extensionCallAst, newContext];
-            }
-            return [
-                {
-                    kind: "conditionalExpression",
-                    condition: {
-                        kind: "binaryExpression",
-                        operatorToken: "==",
-                        left: objectAst,
-                        right: { kind: "literalExpression", text: "null" },
-                    },
-                    whenTrue: { kind: "defaultExpression" },
-                    whenFalse: extensionCallAst,
-                },
-                newContext,
-            ];
-        }
-        const isGlobalSimpleBindingAccess = (() => {
-            if (expr.object.kind !== "identifier")
-                return false;
-            const isLocal = context.localNameMap?.has(expr.object.name) ?? false;
-            if (isLocal)
-                return false;
-            if (expr.object.resolvedClrType !== undefined ||
-                (expr.object.csharpName !== undefined &&
-                    expr.object.resolvedAssembly !== undefined)) {
-                return true;
-            }
-            if (!bindingTypeLeaf)
-                return false;
-            return bindingTypeLeaf === expr.object.name;
-        })();
-        if (isStaticTypeReference(expr, context) || isGlobalSimpleBindingAccess) {
-            // Static access: emit full CLR type and member with global:: prefix
-            return [
-                {
-                    kind: "identifierExpression",
-                    identifier: `global::${type}.${escapedMember}`,
-                },
-                context,
-            ];
-        }
-        else {
-            // Instance access: emit object.ClrMemberName
-            const [objectAst, newContext] = emitExpressionAst(expr.object, context);
-            if (expr.isOptional) {
-                return [
-                    {
-                        kind: "conditionalMemberAccessExpression",
-                        expression: objectAst,
-                        memberName: escapedMember,
-                    },
-                    newContext,
-                ];
-            }
-            return [
-                {
-                    kind: "memberAccessExpression",
-                    expression: objectAst,
-                    memberName: escapedMember,
-                },
-                newContext,
-            ];
-        }
-    }
-    const [objectAst, newContext] = emitExpressionAst(expr.object, context);
-    if (expr.isComputed) {
-        const accessKind = expr.accessKind;
-        if (accessKind === undefined || accessKind === "unknown") {
-            throw new Error(`Internal Compiler Error: Computed accessKind was not classified during IR build ` +
-                `(accessKind=${accessKind ?? "undefined"}).`);
-        }
-        const indexContext = { ...newContext, isArrayIndex: true };
-        const [propAst, contextWithIndex] = emitExpressionAst(expr.property, indexContext);
-        const finalContext = { ...contextWithIndex, isArrayIndex: false };
-        if (accessKind === "dictionary") {
-            if (expr.isOptional) {
-                return [
-                    {
-                        kind: "conditionalElementAccessExpression",
-                        expression: objectAst,
-                        arguments: [propAst],
-                    },
-                    finalContext,
-                ];
-            }
-            return [
-                {
-                    kind: "elementAccessExpression",
-                    expression: objectAst,
-                    arguments: [propAst],
-                },
-                finalContext,
-            ];
-        }
-        // HARD GATE: clrIndexer + stringChar require Int32 proof
-        const indexExpr = expr.property;
-        if (!hasInt32Proof(indexExpr)) {
-            const propText = extractCalleeNameFromAst(propAst);
-            throw new Error(`Internal Compiler Error: CLR indexer requires Int32 index (accessKind=${accessKind}). ` +
-                `Expression '${propText}' has no Int32 proof. ` +
-                `This should have been caught by the numeric proof pass (TSN5107).`);
-        }
-        if (accessKind === "stringChar") {
-            const elementAccess = expr.isOptional
-                ? {
-                    kind: "conditionalElementAccessExpression",
-                    expression: objectAst,
-                    arguments: [propAst],
-                }
-                : {
-                    kind: "elementAccessExpression",
-                    expression: objectAst,
-                    arguments: [propAst],
-                };
-            const narrowedExpectedType = expectedType
-                ? stripNullish(expectedType)
-                : undefined;
-            const resolvedExpectedType = narrowedExpectedType
-                ? resolveTypeAlias(narrowedExpectedType, context)
-                : undefined;
-            const expectsChar = (resolvedExpectedType?.kind === "primitiveType" &&
-                resolvedExpectedType.name === "char") ||
-                (resolvedExpectedType?.kind === "referenceType" &&
-                    resolvedExpectedType.name === "char");
-            if (expectsChar) {
-                return [elementAccess, finalContext];
-            }
-            // str[i] returns char in C#, but JS/TS surface semantics expect a string
-            // in non-char contexts. Convert char → string at the emission boundary.
-            return [
-                {
-                    kind: "invocationExpression",
-                    expression: {
-                        kind: "memberAccessExpression",
-                        expression: elementAccess,
-                        memberName: "ToString",
-                    },
-                    arguments: [],
-                },
-                finalContext,
-            ];
-        }
-        if (expr.isOptional) {
-            return [
-                {
-                    kind: "conditionalElementAccessExpression",
-                    expression: objectAst,
-                    arguments: [propAst],
-                },
-                finalContext,
-            ];
-        }
-        return [
-            {
-                kind: "elementAccessExpression",
-                expression: objectAst,
-                arguments: [propAst],
-            },
-            finalContext,
-        ];
-    }
-    // Property access
-    const prop = expr.property;
-    const objectType = expr.object.inferredType;
-    // Handle explicit interface view properties (As_IInterface)
-    if (isExplicitViewProperty(prop)) {
-        const interfaceName = extractInterfaceNameFromView(prop);
-        if (interfaceName) {
-            // Emit as C# interface cast: ((IInterface)obj)
-            const interfaceType = {
-                kind: "referenceType",
-                name: interfaceName,
-            };
-            const [interfaceTypeAst, ctxAfterType] = emitTypeAst(interfaceType, newContext);
-            return [
-                {
-                    kind: "castExpression",
-                    type: interfaceTypeAst,
-                    expression: objectAst,
-                },
-                ctxAfterType,
-            ];
-        }
+    const bindingResult = tryEmitMemberBindingAccess(expr, context, usage);
+    if (bindingResult) {
+        return bindingResult;
     }
-    // Dictionary pseudo-members:
-    // - dict.Keys   -> new List<TKey>(dict.Keys).ToArray()
-    // - dict.Values -> new List<TValue>(dict.Values).ToArray()
-    //
-    // We expose these as array-typed on the frontend, so emit array materialization
-    // here to keep C# behavior aligned with inferred IR types.
-    const resolvedObjectType = objectType
-        ? resolveTypeAlias(stripNullish(objectType), context)
-        : undefined;
-    if (resolvedObjectType?.kind === "dictionaryType") {
-        if (prop === "Keys" || prop === "Values") {
-            const collectionMemberName = emitCSharpName(prop, "properties", context);
-            const sourceCollectionAst = {
-                kind: "memberAccessExpression",
-                expression: objectAst,
-                memberName: collectionMemberName,
-            };
-            const elementType = prop === "Keys"
-                ? resolvedObjectType.keyType
-                : resolvedObjectType.valueType;
-            const [elementTypeAst, ctxAfterType] = emitTypeAst(elementType, newContext);
-            const listTypeAst = {
-                kind: "identifierType",
-                name: "global::System.Collections.Generic.List",
-                typeArguments: [elementTypeAst],
-            };
-            const listExprAst = {
-                kind: "objectCreationExpression",
-                type: listTypeAst,
-                arguments: [sourceCollectionAst],
-            };
-            return [
-                {
-                    kind: "invocationExpression",
-                    expression: {
-                        kind: "memberAccessExpression",
-                        expression: listExprAst,
-                        memberName: "ToArray",
-                    },
-                    arguments: [],
-                },
-                ctxAfterType,
-            ];
-        }
-        if (prop === "Count" || prop === "Length") {
-            return [
-                {
-                    kind: expr.isOptional
-                        ? "conditionalMemberAccessExpression"
-                        : "memberAccessExpression",
-                    expression: objectAst,
-                    memberName: "Count",
-                },
-                newContext,
-            ];
-        }
-        const keyAst = createStringLiteralExpression(prop);
-        if (expr.isOptional) {
-            return [
-                {
-                    kind: "conditionalElementAccessExpression",
-                    expression: objectAst,
-                    arguments: [keyAst],
-                },
-                newContext,
-            ];
-        }
-        return [
-            {
-                kind: "elementAccessExpression",
-                expression: objectAst,
-                arguments: [keyAst],
-            },
-            newContext,
-        ];
-    }
-    // Regular property access
-    const memberName = emitMemberName(expr.object, objectType, prop, context, usage);
+    const [rawObjectAst, newContext] = emitExpressionAst(expr.object, context);
+    const objectAst = expr.isOptional
+        ? rawObjectAst
+        : (tryStripConditionalNullishGuardAst(rawObjectAst) ?? rawObjectAst);
     if (usage === "value") {
-        if (resolvedObjectType?.kind === "arrayType" ||
-            resolvedObjectType?.kind === "tupleType") {
-            if (prop === "length" || prop === "Length" || prop === "Count") {
-                return [
-                    {
-                        kind: expr.isOptional
-                            ? "conditionalMemberAccessExpression"
-                            : "memberAccessExpression",
-                        expression: objectAst,
-                        memberName: "Length",
-                    },
-                    newContext,
-                ];
-            }
+        const jsSurfaceArrayLengthAccess = tryEmitJsSurfaceArrayLikeLengthAccess(expr, objectAst, objectType, newContext);
+        if (jsSurfaceArrayLengthAccess) {
+            return jsSurfaceArrayLengthAccess;
         }
     }
-    if (expr.isOptional) {
-        return [
-            {
-                kind: "conditionalMemberAccessExpression",
-                expression: objectAst,
-                memberName,
-            },
-            newContext,
-        ];
+    if (expr.isComputed) {
+        return emitComputedAccess(expr, objectAst, objectType, context, newContext, usage, expectedType);
     }
-    return [
-        {
-            kind: "memberAccessExpression",
-            expression: objectAst,
-            memberName,
-        },
-        newContext,
-    ];
+    return emitPropertyAccess(expr, objectAst, objectType, context, newContext, usage, expectedType);
 };
 //# sourceMappingURL=access.js.map