@tsonic/emitter 0.0.71 → 0.0.73

package/dist/expression-emitter.js

@@ -5,8 +5,10 @@
  * Primary entry point is emitExpressionAst which returns [CSharpExpressionAst, EmitterContext].
  */
 import { emitTypeAst } from "./type-emitter.js";
-import { substituteTypeArgs, resolveTypeAlias, stripNullish, } from "./core/semantic/type-resolution.js";
+import { substituteTypeArgs, resolveTypeAlias, stripNullish, getPropertyType, getAllPropertySignatures, resolveLocalTypeInfo, } from "./core/semantic/type-resolution.js";
 import { renderTypeAst } from "./core/format/backend-ast/utils.js";
+import { allocateLocalName } from "./core/format/local-names.js";
+import { emitCSharpName } from "./naming-policy.js";
 // Import expression emitters from specialized modules
 import { emitLiteral } from "./expressions/literals.js";
 import { emitIdentifier } from "./expressions/identifiers.js";
@@ -17,6 +19,802 @@ import { emitNew } from "./expressions/calls/new-emitter.js";
 import { emitBinary, emitLogical, emitUnary, emitUpdate, emitAssignment, emitConditional, } from "./expressions/operators.js";
 import { emitFunctionExpression, emitArrowFunction, } from "./expressions/functions.js";
 import { emitTemplateLiteral, emitSpread, emitAwait, } from "./expressions/other.js";
+const hasNullishBranch = (type) => {
+    if (!type || type.kind !== "unionType")
+        return false;
+    return type.types.some((member) => member.kind === "primitiveType" &&
+        (member.name === "null" || member.name === "undefined"));
+};
+const buildDelegateType = (parameterTypes, returnType) => ({
+    kind: "identifierType",
+    name: "global::System.Func",
+    typeArguments: [...parameterTypes, returnType],
+});
+const collectLocalStructuralProperties = (info) => {
+    switch (info.kind) {
+        case "interface": {
+            if (info.members.some((member) => member.kind === "methodSignature")) {
+                return undefined;
+            }
+            const props = [];
+            for (const member of info.members) {
+                if (member.kind !== "propertySignature")
+                    continue;
+                props.push({
+                    name: member.name,
+                    type: member.type,
+                    isOptional: member.isOptional,
+                });
+            }
+            return props;
+        }
+        case "class": {
+            if (info.members.some((member) => member.kind === "methodDeclaration")) {
+                return undefined;
+            }
+            const props = [];
+            for (const member of info.members) {
+                if (member.kind !== "propertyDeclaration")
+                    continue;
+                if (!member.type)
+                    return undefined;
+                props.push({
+                    name: member.name,
+                    type: member.type,
+                    isOptional: false,
+                });
+            }
+            return props;
+        }
+        case "typeAlias": {
+            const aliasType = info.type;
+            if (aliasType.kind !== "objectType")
+                return undefined;
+            if (aliasType.members.some((member) => member.kind === "methodSignature")) {
+                return undefined;
+            }
+            return aliasType.members
+                .filter((member) => member.kind === "propertySignature")
+                .map((member) => ({
+                name: member.name,
+                type: member.type,
+                isOptional: member.isOptional,
+            }));
+        }
+        default:
+            return undefined;
+    }
+};
+const parseEmitterClrTypeString = (clrType) => {
+    if (clrType === "System.Void" || clrType === "void") {
+        return { kind: "voidType" };
+    }
+    const primitiveMap = {
+        "System.String": { kind: "primitiveType", name: "string" },
+        string: { kind: "primitiveType", name: "string" },
+        "System.Int32": { kind: "primitiveType", name: "int" },
+        int: { kind: "primitiveType", name: "int" },
+        "System.Double": { kind: "primitiveType", name: "number" },
+        double: { kind: "primitiveType", name: "number" },
+        "System.Boolean": { kind: "primitiveType", name: "boolean" },
+        bool: { kind: "primitiveType", name: "boolean" },
+        "System.Char": { kind: "primitiveType", name: "char" },
+        char: { kind: "primitiveType", name: "char" },
+        "System.Int64": { kind: "referenceType", name: "long" },
+        long: { kind: "referenceType", name: "long" },
+        "System.Object": { kind: "referenceType", name: "object" },
+        object: { kind: "referenceType", name: "object" },
+    };
+    const primitive = primitiveMap[clrType];
+    if (primitive)
+        return primitive;
+    if (clrType.endsWith("[]")) {
+        return {
+            kind: "arrayType",
+            elementType: parseEmitterClrTypeString(clrType.slice(0, -2)),
+        };
+    }
+    if (clrType.endsWith("*")) {
+        return parseEmitterClrTypeString(clrType.slice(0, -1));
+    }
+    if (clrType.startsWith("System.Nullable`1")) {
+        const innerMatch = clrType.match(/System\.Nullable`1\[\[([^\]]+)\]\]/);
+        if (innerMatch?.[1]) {
+            return {
+                kind: "unionType",
+                types: [
+                    parseEmitterClrTypeString(innerMatch[1]),
+                    { kind: "primitiveType", name: "undefined" },
+                ],
+            };
+        }
+    }
+    if (/^T\d*$/.test(clrType) || /^T[A-Z][a-zA-Z]*$/.test(clrType)) {
+        return { kind: "typeParameterType", name: clrType };
+    }
+    const underscoreInstantiationMatch = clrType.match(/^(.+?)_(\d+)\[\[(.+)\]\]$/);
+    if (underscoreInstantiationMatch?.[1] &&
+        underscoreInstantiationMatch[2] &&
+        underscoreInstantiationMatch[3]) {
+        const baseName = underscoreInstantiationMatch[1];
+        const arity = Number.parseInt(underscoreInstantiationMatch[2], 10);
+        const args = splitEmitterTypeArguments(underscoreInstantiationMatch[3]);
+        return {
+            kind: "referenceType",
+            name: `${baseName}_${arity}`,
+            typeArguments: args.length === arity
+                ? args.map((arg) => parseEmitterClrTypeString(arg.trim()))
+                : undefined,
+            resolvedClrType: clrType,
+        };
+    }
+    const genericMatch = clrType.match(/^(.+)`(\d+)(?:\[\[(.+)\]\])?$/);
+    if (genericMatch?.[1] && genericMatch[2]) {
+        const baseName = genericMatch[1];
+        const arity = Number.parseInt(genericMatch[2], 10);
+        const typeArguments = genericMatch[3]
+            ? splitEmitterTypeArguments(genericMatch[3]).map((arg) => parseEmitterClrTypeString(arg.trim()))
+            : Array.from({ length: arity }, (_, index) => ({
+                kind: "typeParameterType",
+                name: index === 0 ? "T" : `T${index + 1}`,
+            }));
+        return {
+            kind: "referenceType",
+            name: baseName,
+            typeArguments,
+            resolvedClrType: clrType,
+        };
+    }
+    return {
+        kind: "referenceType",
+        name: clrType,
+        resolvedClrType: clrType,
+    };
+};
+const splitEmitterTypeArguments = (text) => {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const char of text) {
+        if (char === "[") {
+            depth++;
+            current += char;
+            continue;
+        }
+        if (char === "]") {
+            depth--;
+            current += char;
+            continue;
+        }
+        if (char === "," && depth === 0) {
+            parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+};
+const addUndefinedToBindingType = (type) => {
+    if (type.kind === "unionType" &&
+        type.types.some((candidate) => candidate.kind === "primitiveType" && candidate.name === "undefined")) {
+        return type;
+    }
+    return {
+        kind: "unionType",
+        types: [type, { kind: "primitiveType", name: "undefined" }],
+    };
+};
+const parseBindingPropertyType = (normalizedSignature) => {
+    if (!normalizedSignature) {
+        return { kind: "unknownType" };
+    }
+    const indexerMatch = normalizedSignature.match(/\|\[[^\]]*\]:([^|]+)\|/);
+    if (indexerMatch?.[1]) {
+        return parseEmitterClrTypeString(indexerMatch[1]);
+    }
+    const propertyMatch = normalizedSignature.match(/\|:([^|]+)\|/);
+    if (propertyMatch?.[1]) {
+        return parseEmitterClrTypeString(propertyMatch[1]);
+    }
+    const fieldParts = normalizedSignature.split("|");
+    if (fieldParts.length >= 2 && fieldParts[1]) {
+        return parseEmitterClrTypeString(fieldParts[1]);
+    }
+    return { kind: "unknownType" };
+};
+const collectBindingStructuralProperties = (type, context) => {
+    const registry = context.bindingsRegistry;
+    if (!registry || registry.size === 0) {
+        return undefined;
+    }
+    const candidates = new Set();
+    const add = (value) => {
+        if (value && value.length > 0) {
+            candidates.add(value);
+            if (value.includes(".")) {
+                candidates.add(value.split(".").pop() ?? value);
+            }
+        }
+    };
+    add(type.name);
+    add(type.resolvedClrType);
+    add(type.typeId?.tsName);
+    add(type.typeId?.clrName);
+    for (const candidate of candidates) {
+        const binding = registry.get(candidate);
+        if (!binding)
+            continue;
+        if (binding.members.some((member) => member.kind === "method")) {
+            return undefined;
+        }
+        const props = binding.members
+            .filter((member) => member.kind === "property")
+            .map((member) => ({
+            name: member.alias,
+            type: member.semanticType !== undefined
+                ? member.semanticOptional === true
+                    ? addUndefinedToBindingType(member.semanticType)
+                    : member.semanticType
+                : parseBindingPropertyType(member.signature),
+            isOptional: member.semanticOptional === true,
+        }));
+        if (props.length > 0) {
+            return props;
+        }
+    }
+    return undefined;
+};
+const collectStructuralProperties = (type, context) => {
+    if (!type)
+        return undefined;
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    if (resolved.kind === "objectType") {
+        if (resolved.members.some((member) => member.kind === "methodSignature")) {
+            return undefined;
+        }
+        return resolved.members
+            .filter((member) => member.kind === "propertySignature")
+            .map((member) => ({
+            name: member.name,
+            type: member.type,
+            isOptional: member.isOptional,
+        }));
+    }
+    if (resolved.kind !== "referenceType") {
+        return undefined;
+    }
+    const inheritedInterfaceProps = getAllPropertySignatures(resolved, context);
+    if (inheritedInterfaceProps && inheritedInterfaceProps.length > 0) {
+        return inheritedInterfaceProps.map((member) => ({
+            name: member.name,
+            type: member.type,
+            isOptional: member.isOptional,
+        }));
+    }
+    const localInfo = resolveLocalTypeInfo(resolved, context)?.info;
+    if (localInfo) {
+        return collectLocalStructuralProperties(localInfo);
+    }
+    if (resolved.structuralMembers && resolved.structuralMembers.length > 0) {
+        if (resolved.structuralMembers.some((member) => member.kind === "methodSignature")) {
+            return undefined;
+        }
+        return resolved.structuralMembers
+            .filter((member) => member.kind === "propertySignature")
+            .map((member) => ({
+            name: member.name,
+            type: member.type,
+            isOptional: member.isOptional,
+        }));
+    }
+    return collectBindingStructuralProperties(resolved, context);
+};
+const resolveAnonymousStructuralReferenceType = (type, context) => {
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    if (resolved.kind !== "objectType")
+        return undefined;
+    const propertyNames = resolved.members
+        .filter((member) => member.kind === "propertySignature")
+        .map((member) => member.name)
+        .sort();
+    if (propertyNames.length === 0)
+        return undefined;
+    const candidateMaps = [];
+    if (context.localTypes) {
+        candidateMaps.push(context.localTypes);
+    }
+    if (context.options.moduleMap) {
+        for (const module of context.options.moduleMap.values()) {
+            if (module.localTypes) {
+                candidateMaps.push(module.localTypes);
+            }
+        }
+    }
+    const matches = new Set();
+    for (const localTypes of candidateMaps) {
+        for (const [typeName, info] of localTypes.entries()) {
+            if (info.kind !== "class" || !typeName.startsWith("__Anon_"))
+                continue;
+            const candidateProps = info.members
+                .filter((member) => member.kind === "propertyDeclaration")
+                .map((member) => member.name)
+                .sort();
+            if (candidateProps.length === propertyNames.length &&
+                candidateProps.every((name, index) => name === propertyNames[index])) {
+                matches.add(typeName);
+            }
+        }
+    }
+    if (matches.size !== 1)
+        return undefined;
+    const onlyMatch = [...matches][0];
+    return onlyMatch ? { kind: "referenceType", name: onlyMatch } : undefined;
+};
+const isSameNominalType = (sourceType, targetType, context) => {
+    if (!sourceType || !targetType)
+        return false;
+    const sourceBase = stripNullish(sourceType);
+    const targetBase = stripNullish(targetType);
+    if (sourceBase.kind === "referenceType" &&
+        targetBase.kind === "referenceType") {
+        if (sourceBase.name === targetBase.name) {
+            return true;
+        }
+        if (sourceBase.typeId?.stableId !== undefined &&
+            sourceBase.typeId.stableId === targetBase.typeId?.stableId) {
+            return true;
+        }
+        if (sourceBase.resolvedClrType !== undefined &&
+            sourceBase.resolvedClrType === targetBase.resolvedClrType) {
+            return true;
+        }
+    }
+    const sourceResolved = resolveTypeAlias(sourceBase, context);
+    const targetResolved = resolveTypeAlias(targetBase, context);
+    if (sourceResolved.kind !== "referenceType" ||
+        targetResolved.kind !== "referenceType") {
+        return false;
+    }
+    return (sourceResolved.name === targetResolved.name ||
+        (sourceResolved.resolvedClrType !== undefined &&
+            sourceResolved.resolvedClrType === targetResolved.resolvedClrType));
+};
+const buildStructuralSourceAccess = (sourceExpression, sourceType, propertyName, context) => {
+    const resolvedSource = resolveTypeAlias(stripNullish(sourceType), context);
+    if (resolvedSource.kind === "dictionaryType") {
+        return {
+            kind: "elementAccessExpression",
+            expression: sourceExpression,
+            arguments: [
+                {
+                    kind: "literalExpression",
+                    text: JSON.stringify(propertyName),
+                },
+            ],
+        };
+    }
+    return {
+        kind: "memberAccessExpression",
+        expression: sourceExpression,
+        memberName: emitCSharpName(propertyName, "properties", context),
+    };
+};
+const isDirectlyReusableExpression = (expression) => expression.kind === "identifierExpression" ||
+    expression.kind === "memberAccessExpression" ||
+    expression.kind === "elementAccessExpression";
+const getArrayElementType = (type, context) => {
+    if (!type)
+        return undefined;
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    if (resolved.kind === "arrayType")
+        return resolved.elementType;
+    if (resolved.kind === "tupleType") {
+        if (resolved.elementTypes.length === 1)
+            return resolved.elementTypes[0];
+        return undefined;
+    }
+    if (resolved.kind === "referenceType" &&
+        (resolved.name === "Array" ||
+            resolved.name === "ReadonlyArray" ||
+            resolved.name === "JSArray") &&
+        resolved.typeArguments?.length === 1) {
+        return resolved.typeArguments[0];
+    }
+    return undefined;
+};
+const getDictionaryValueType = (type, context) => {
+    if (!type)
+        return undefined;
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    if (resolved.kind !== "dictionaryType")
+        return undefined;
+    return resolved.valueType;
+};
+const tryAdaptStructuralExpressionAst = (emittedAst, sourceType, context, expectedType) => {
+    if (!expectedType || !sourceType)
+        return undefined;
+    if (isSameNominalType(sourceType, expectedType, context)) {
+        return undefined;
+    }
+    const strippedExpectedType = stripNullish(expectedType);
+    const anonymousStructuralTarget = resolveAnonymousStructuralReferenceType(expectedType, context);
+    const targetStructuralType = anonymousStructuralTarget ??
+        resolveTypeAlias(strippedExpectedType, context);
+    const targetEmissionType = anonymousStructuralTarget ??
+        (strippedExpectedType.kind === "referenceType"
+            ? strippedExpectedType
+            : undefined);
+    const targetProps = collectStructuralProperties(targetStructuralType, context);
+    if (targetProps && targetProps.length > 0) {
+        if (!targetEmissionType && targetStructuralType.kind === "objectType") {
+            return undefined;
+        }
+        const sourceProps = collectStructuralProperties(sourceType, context);
+        if (!sourceProps || sourceProps.length === 0)
+            return undefined;
+        const sourcePropNames = new Set(sourceProps.map((prop) => prop.name));
+        const materializedProps = targetProps.filter((prop) => prop.isOptional || sourcePropNames.has(prop.name));
+        if (materializedProps.length === 0)
+            return undefined;
+        for (const prop of targetProps) {
+            if (!prop.isOptional && !sourcePropNames.has(prop.name)) {
+                return undefined;
+            }
+            if (!sourcePropNames.has(prop.name))
+                continue;
+            if (!getPropertyType(sourceType, prop.name, context)) {
+                return undefined;
+            }
+        }
+        let currentContext = context;
+        const [targetTypeAst, withType] = emitTypeAst(targetEmissionType ?? targetStructuralType, currentContext);
+        currentContext = withType;
+        const safeTargetTypeAst = targetTypeAst.kind === "nullableType"
+            ? targetTypeAst.underlyingType
+            : targetTypeAst;
+        const sourcePropMap = new Map(sourceProps.map((prop) => [prop.name, prop]));
+        const buildInitializer = (sourceExpression, initContext) => {
+            let currentInitContext = initContext;
+            const assignments = materializedProps
+                .filter((prop) => sourcePropNames.has(prop.name))
+                .map((prop) => {
+                const sourceProp = sourcePropMap.get(prop.name);
+                const sourceAccess = buildStructuralSourceAccess(sourceExpression, sourceType, prop.name, currentInitContext);
+                const [adaptedValueAst, adaptedValueContext] = tryAdaptStructuralExpressionAst(sourceAccess, sourceProp?.type, currentInitContext, prop.type) ?? [sourceAccess, currentInitContext];
+                currentInitContext = adaptedValueContext;
+                return {
+                    kind: "assignmentExpression",
+                    operatorToken: "=",
+                    left: {
+                        kind: "identifierExpression",
+                        identifier: emitCSharpName(prop.name, "properties", currentInitContext),
+                    },
+                    right: adaptedValueAst,
+                };
+            });
+            return [
+                {
+                    kind: "objectCreationExpression",
+                    type: safeTargetTypeAst,
+                    arguments: [],
+                    initializer: assignments,
+                },
+                currentInitContext,
+            ];
+        };
+        const sourceMayBeNullish = hasNullishBranch(sourceType);
+        if (emittedAst.kind === "identifierExpression") {
+            const [initializer, initializerContext] = buildInitializer(emittedAst, currentContext);
+            if (!sourceMayBeNullish) {
+                return [initializer, initializerContext];
+            }
+            return [
+                {
+                    kind: "conditionalExpression",
+                    condition: {
+                        kind: "binaryExpression",
+                        operatorToken: "==",
+                        left: emittedAst,
+                        right: { kind: "literalExpression", text: "null" },
+                    },
+                    whenTrue: {
+                        kind: "defaultExpression",
+                        type: safeTargetTypeAst,
+                    },
+                    whenFalse: initializer,
+                },
+                initializerContext,
+            ];
+        }
+        const temp = allocateLocalName("__struct", currentContext);
+        currentContext = temp.context;
+        const tempIdentifier = {
+            kind: "identifierExpression",
+            identifier: temp.emittedName,
+        };
+        const statements = [
+            {
+                kind: "localDeclarationStatement",
+                modifiers: [],
+                type: { kind: "varType" },
+                declarators: [{ name: temp.emittedName, initializer: emittedAst }],
+            },
+        ];
+        if (sourceMayBeNullish) {
+            statements.push({
+                kind: "ifStatement",
+                condition: {
+                    kind: "binaryExpression",
+                    operatorToken: "==",
+                    left: tempIdentifier,
+                    right: { kind: "literalExpression", text: "null" },
+                },
+                thenStatement: {
+                    kind: "blockStatement",
+                    statements: [
+                        {
+                            kind: "returnStatement",
+                            expression: {
+                                kind: "defaultExpression",
+                                type: safeTargetTypeAst,
+                            },
+                        },
+                    ],
+                },
+            });
+        }
+        const [initializer, initializerContext] = buildInitializer(tempIdentifier, currentContext);
+        currentContext = initializerContext;
+        statements.push({
+            kind: "returnStatement",
+            expression: initializer,
+        });
+        const lambdaAst = {
+            kind: "lambdaExpression",
+            isAsync: false,
+            parameters: [],
+            body: {
+                kind: "blockStatement",
+                statements,
+            },
+        };
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "parenthesizedExpression",
+                    expression: {
+                        kind: "castExpression",
+                        type: buildDelegateType([], safeTargetTypeAst),
+                        expression: {
+                            kind: "parenthesizedExpression",
+                            expression: lambdaAst,
+                        },
+                    },
+                },
+                arguments: [],
+            },
+            currentContext,
+        ];
+    }
+    const targetElementType = getArrayElementType(expectedType, context);
+    const sourceElementType = getArrayElementType(sourceType, context);
+    if (targetElementType && sourceElementType) {
+        const item = allocateLocalName("__item", context);
+        let currentContext = item.context;
+        const itemIdentifier = {
+            kind: "identifierExpression",
+            identifier: item.emittedName,
+        };
+        const [adaptedElementAst, adaptedContext] = tryAdaptStructuralExpressionAst(itemIdentifier, sourceElementType, currentContext, targetElementType) ?? [undefined, currentContext];
+        currentContext = adaptedContext;
+        if (adaptedElementAst !== undefined) {
+            const selectAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Linq.Enumerable.Select",
+                },
+                arguments: [
+                    emittedAst,
+                    {
+                        kind: "lambdaExpression",
+                        isAsync: false,
+                        parameters: [{ name: item.emittedName }],
+                        body: adaptedElementAst,
+                    },
+                ],
+            };
+            const toArrayAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Linq.Enumerable.ToArray",
+                },
+                arguments: [selectAst],
+            };
+            if (!hasNullishBranch(sourceType)) {
+                return [toArrayAst, currentContext];
+            }
+            if (isDirectlyReusableExpression(emittedAst)) {
+                return [
+                    {
+                        kind: "conditionalExpression",
+                        condition: {
+                            kind: "binaryExpression",
+                            operatorToken: "==",
+                            left: emittedAst,
+                            right: { kind: "literalExpression", text: "null" },
+                        },
+                        whenTrue: { kind: "defaultExpression" },
+                        whenFalse: toArrayAst,
+                    },
+                    currentContext,
+                ];
+            }
+        }
+    }
+    const targetValueType = getDictionaryValueType(expectedType, context);
+    const sourceValueType = getDictionaryValueType(sourceType, context);
+    if (targetValueType && sourceValueType) {
+        let currentContext = context;
+        const [targetValueTypeAst, valueTypeContext] = emitTypeAst(targetValueType, currentContext);
+        currentContext = valueTypeContext;
+        const dictTypeAst = {
+            kind: "identifierType",
+            name: "global::System.Collections.Generic.Dictionary",
+            typeArguments: [
+                { kind: "predefinedType", keyword: "string" },
+                targetValueTypeAst,
+            ],
+        };
+        const sourceTemp = allocateLocalName("__dict", currentContext);
+        currentContext = sourceTemp.context;
+        const entryTemp = allocateLocalName("__entry", currentContext);
+        currentContext = entryTemp.context;
+        const resultTemp = allocateLocalName("__result", currentContext);
+        currentContext = resultTemp.context;
+        const entryValueAst = {
+            kind: "memberAccessExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: entryTemp.emittedName,
+            },
+            memberName: "Value",
+        };
+        const [adaptedValueAst, adaptedContext] = tryAdaptStructuralExpressionAst(entryValueAst, sourceValueType, currentContext, targetValueType) ?? [undefined, currentContext];
+        currentContext = adaptedContext;
+        if (adaptedValueAst !== undefined) {
+            const statements = [
+                {
+                    kind: "localDeclarationStatement",
+                    modifiers: [],
+                    type: { kind: "varType" },
+                    declarators: [
+                        {
+                            name: sourceTemp.emittedName,
+                            initializer: emittedAst,
+                        },
+                    ],
+                },
+                {
+                    kind: "ifStatement",
+                    condition: {
+                        kind: "binaryExpression",
+                        operatorToken: "==",
+                        left: {
+                            kind: "identifierExpression",
+                            identifier: sourceTemp.emittedName,
+                        },
+                        right: { kind: "literalExpression", text: "null" },
+                    },
+                    thenStatement: {
+                        kind: "blockStatement",
+                        statements: [
+                            {
+                                kind: "returnStatement",
+                                expression: { kind: "defaultExpression", type: dictTypeAst },
+                            },
+                        ],
+                    },
+                },
+                {
+                    kind: "localDeclarationStatement",
+                    modifiers: [],
+                    type: { kind: "varType" },
+                    declarators: [
+                        {
+                            name: resultTemp.emittedName,
+                            initializer: {
+                                kind: "objectCreationExpression",
+                                type: dictTypeAst,
+                                arguments: [],
+                            },
+                        },
+                    ],
+                },
+                {
+                    kind: "foreachStatement",
+                    isAwait: false,
+                    type: { kind: "varType" },
+                    identifier: entryTemp.emittedName,
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: sourceTemp.emittedName,
+                    },
+                    body: {
+                        kind: "blockStatement",
+                        statements: [
+                            {
+                                kind: "expressionStatement",
+                                expression: {
+                                    kind: "assignmentExpression",
+                                    operatorToken: "=",
+                                    left: {
+                                        kind: "elementAccessExpression",
+                                        expression: {
+                                            kind: "identifierExpression",
+                                            identifier: resultTemp.emittedName,
+                                        },
+                                        arguments: [
+                                            {
+                                                kind: "memberAccessExpression",
+                                                expression: {
+                                                    kind: "identifierExpression",
+                                                    identifier: entryTemp.emittedName,
+                                                },
+                                                memberName: "Key",
+                                            },
+                                        ],
+                                    },
+                                    right: adaptedValueAst,
+                                },
+                            },
+                        ],
+                    },
+                },
+                {
+                    kind: "returnStatement",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: resultTemp.emittedName,
+                    },
+                },
+            ];
+            return [
+                {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "castExpression",
+                            type: buildDelegateType([], dictTypeAst),
+                            expression: {
+                                kind: "parenthesizedExpression",
+                                expression: {
+                                    kind: "lambdaExpression",
+                                    isAsync: false,
+                                    parameters: [],
+                                    body: {
+                                        kind: "blockStatement",
+                                        statements,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    arguments: [],
+                },
+                currentContext,
+            ];
+        }
+    }
+    return undefined;
+};
 const getBareTypeParameterName = (type, context) => {
     if (type.kind === "typeParameterType")
         return type.name;
@@ -691,7 +1489,8 @@ export const emitExpressionAst = (expr, context, expectedType) => {
     })();
     const [castedAst, castedContext] = maybeCastNullishTypeParamAst(expr, ast, newContext, expectedType);
     const [dictUpcastAst, dictUpcastContext] = maybeUpcastDictionaryUnionValueAst(expr, castedAst, castedContext, expectedType);
-    const [stringAdjustedAst, stringAdjustedContext] = maybeConvertCharToStringAst(expr, dictUpcastAst, dictUpcastContext, expectedType);
+    const [materializedAst, materializedContext] = tryAdaptStructuralExpressionAst(dictUpcastAst, expr.inferredType, dictUpcastContext, expectedType) ?? [dictUpcastAst, dictUpcastContext];
+    const [stringAdjustedAst, stringAdjustedContext] = maybeConvertCharToStringAst(expr, materializedAst, materializedContext, expectedType);
     return maybeUnwrapNullableValueTypeAst(expr, stringAdjustedAst, stringAdjustedContext, expectedType);
 };
 // Re-export commonly used functions from barrel