@tsonic/emitter 0.0.73 → 0.0.75

package/dist/core/semantic/storage-erased-adaptation.test.js

@@ -0,0 +1,271 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { createContext } from "../../emitter-types/context.js";
+import { emitTypeAst } from "../../type-emitter.js";
+import { identifierExpression } from "../format/backend-ast/builders.js";
+import { matchesSemanticExpectedType } from "./expected-type-matching.js";
+import { adaptStorageErasedValueAst } from "./storage-erased-adaptation.js";
+describe("storage-erased-adaptation", () => {
+    it("matches semantic expected types after stripping nullish wrappers", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        expect(matchesSemanticExpectedType({
+            kind: "unionType",
+            types: [
+                { kind: "primitiveType", name: "string" },
+                { kind: "primitiveType", name: "undefined" },
+            ],
+        }, { kind: "primitiveType", name: "string" }, context)).to.equal(true);
+    });
+    it("does not treat generic reference types with different type arguments as assignment-compatible", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        expect(matchesSemanticExpectedType({
+            kind: "referenceType",
+            name: "Iterable",
+            typeArguments: [{ kind: "unknownType" }],
+        }, {
+            kind: "referenceType",
+            name: "Iterable",
+            typeArguments: [{ kind: "typeParameterType", name: "T" }],
+        }, context)).to.equal(false);
+    });
+    it("does not structurally match conflicting TypeId references", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        const idMember = {
+            kind: "propertySignature",
+            name: "id",
+            type: { kind: "primitiveType", name: "number" },
+            isOptional: false,
+            isReadonly: false,
+        };
+        expect(matchesSemanticExpectedType({
+            kind: "arrayType",
+            elementType: {
+                kind: "referenceType",
+                name: "Item",
+                resolvedClrType: "Fixture.Channels.domain.Item",
+                typeId: {
+                    stableId: "@fixture/channels:Fixture.Channels.domain.Item",
+                    clrName: "Fixture.Channels.domain.Item",
+                    assemblyName: "@fixture/channels",
+                    tsName: "Item",
+                },
+                structuralMembers: [idMember],
+            },
+        }, {
+            kind: "arrayType",
+            elementType: {
+                kind: "referenceType",
+                name: "Item",
+                resolvedClrType: "Fixture.Channels.repo.Item",
+                typeId: {
+                    stableId: "@fixture/channels:Fixture.Channels.repo.Item",
+                    clrName: "Fixture.Channels.repo.Item",
+                    assemblyName: "@fixture/channels",
+                    tsName: "Item",
+                },
+                structuralMembers: [idMember],
+            },
+        }, context)).to.equal(false);
+    });
+    it("matches named structural union aliases against equivalent anonymous union views", () => {
+        const context = {
+            ...createContext({ rootNamespace: "Test" }),
+            localTypes: new Map([
+                [
+                    "Ok",
+                    {
+                        kind: "typeAlias",
+                        typeParameters: ["T"],
+                        type: {
+                            kind: "objectType",
+                            members: [
+                                {
+                                    kind: "propertySignature",
+                                    name: "success",
+                                    type: { kind: "literalType", value: true },
+                                    isOptional: false,
+                                    isReadonly: false,
+                                },
+                                {
+                                    kind: "propertySignature",
+                                    name: "payload",
+                                    type: { kind: "typeParameterType", name: "T" },
+                                    isOptional: false,
+                                    isReadonly: false,
+                                },
+                            ],
+                        },
+                    },
+                ],
+                [
+                    "Err",
+                    {
+                        kind: "typeAlias",
+                        typeParameters: ["E"],
+                        type: {
+                            kind: "objectType",
+                            members: [
+                                {
+                                    kind: "propertySignature",
+                                    name: "success",
+                                    type: { kind: "literalType", value: false },
+                                    isOptional: false,
+                                    isReadonly: false,
+                                },
+                                {
+                                    kind: "propertySignature",
+                                    name: "error",
+                                    type: { kind: "typeParameterType", name: "E" },
+                                    isOptional: false,
+                                    isReadonly: false,
+                                },
+                            ],
+                        },
+                    },
+                ],
+                [
+                    "Result",
+                    {
+                        kind: "typeAlias",
+                        typeParameters: ["T", "E"],
+                        type: {
+                            kind: "unionType",
+                            types: [
+                                {
+                                    kind: "referenceType",
+                                    name: "Err",
+                                    typeArguments: [{ kind: "typeParameterType", name: "E" }],
+                                },
+                                {
+                                    kind: "referenceType",
+                                    name: "Ok",
+                                    typeArguments: [{ kind: "typeParameterType", name: "T" }],
+                                },
+                            ],
+                        },
+                    },
+                ],
+            ]),
+        };
+        expect(matchesSemanticExpectedType({
+            kind: "unionType",
+            types: [
+                {
+                    kind: "referenceType",
+                    name: "__Anon_Ok",
+                    structuralMembers: [
+                        {
+                            kind: "propertySignature",
+                            name: "success",
+                            type: { kind: "literalType", value: true },
+                            isOptional: false,
+                            isReadonly: false,
+                        },
+                        {
+                            kind: "propertySignature",
+                            name: "payload",
+                            type: { kind: "primitiveType", name: "boolean" },
+                            isOptional: false,
+                            isReadonly: false,
+                        },
+                    ],
+                },
+                {
+                    kind: "referenceType",
+                    name: "__Anon_Err",
+                    structuralMembers: [
+                        {
+                            kind: "propertySignature",
+                            name: "success",
+                            type: { kind: "literalType", value: false },
+                            isOptional: false,
+                            isReadonly: false,
+                        },
+                        {
+                            kind: "propertySignature",
+                            name: "error",
+                            type: { kind: "primitiveType", name: "string" },
+                            isOptional: false,
+                            isReadonly: false,
+                        },
+                    ],
+                },
+            ],
+        }, {
+            kind: "referenceType",
+            name: "Result",
+            typeArguments: [
+                { kind: "primitiveType", name: "boolean" },
+                { kind: "primitiveType", name: "string" },
+            ],
+        }, context)).to.equal(true);
+    });
+    it("reuses the original value when storage already matches the expected type", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        const valueAst = identifierExpression("value");
+        const result = adaptStorageErasedValueAst({
+            valueAst,
+            semanticType: { kind: "primitiveType", name: "string" },
+            storageType: { kind: "primitiveType", name: "string" },
+            expectedType: { kind: "primitiveType", name: "string" },
+            context,
+            emitTypeAst,
+        });
+        expect(result?.[0]).to.equal(valueAst);
+    });
+    it("reifies storage-erased values when semantic meaning matches the expected type", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        const result = adaptStorageErasedValueAst({
+            valueAst: identifierExpression("value"),
+            semanticType: { kind: "primitiveType", name: "string" },
+            storageType: { kind: "referenceType", name: "object" },
+            expectedType: { kind: "primitiveType", name: "string" },
+            context,
+            emitTypeAst,
+        });
+        expect(result?.[0]).to.deep.equal({
+            kind: "castExpression",
+            type: { kind: "predefinedType", keyword: "string" },
+            expression: {
+                kind: "castExpression",
+                type: { kind: "predefinedType", keyword: "object" },
+                expression: identifierExpression("value"),
+            },
+        });
+    });
+    it("materializes nullable exact numeric storage before exact-value assignments", () => {
+        const context = createContext({ rootNamespace: "Test", surface: "@tsonic/js" });
+        const result = adaptStorageErasedValueAst({
+            valueAst: identifierExpression("value"),
+            semanticType: { kind: "primitiveType", name: "int" },
+            storageType: {
+                kind: "unionType",
+                types: [
+                    { kind: "primitiveType", name: "int" },
+                    { kind: "primitiveType", name: "undefined" },
+                ],
+            },
+            expectedType: { kind: "primitiveType", name: "int" },
+            context,
+            emitTypeAst,
+        });
+        expect(result?.[0]).to.deep.equal({
+            kind: "memberAccessExpression",
+            expression: identifierExpression("value"),
+            memberName: "Value",
+        });
+    });
+    it("returns undefined when semantic meaning does not match the expected type", () => {
+        const context = createContext({ rootNamespace: "Test" });
+        const result = adaptStorageErasedValueAst({
+            valueAst: identifierExpression("value"),
+            semanticType: { kind: "primitiveType", name: "number" },
+            storageType: { kind: "referenceType", name: "object" },
+            expectedType: { kind: "primitiveType", name: "string" },
+            context,
+            emitTypeAst,
+        });
+        expect(result).to.equal(undefined);
+    });
+});
+//# sourceMappingURL=storage-erased-adaptation.test.js.map

package/dist/core/semantic/storage-erased-adaptation.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-erased-adaptation.test.js","sourceRoot":"","sources":["../../../src/core/semantic/storage-erased-adaptation.test.ts"],"names":[],"mappings":"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"}

package/dist/core/semantic/storage-types.d.ts

@@ -0,0 +1,8 @@
+import { IrType } from "@tsonic/frontend";
+import type { EmitterContext } from "../../types.js";
+export declare const isObjectStorageType: (type: IrType | undefined, context: EmitterContext) => boolean;
+export declare function shouldUseBroadObjectForUnionStorage(type: Extract<IrType, {
+    kind: "unionType";
+}>, context: EmitterContext, activeArrayKeys?: ReadonlySet<string>): boolean;
+export declare const normalizeRuntimeStorageType: (type: IrType | undefined, context: EmitterContext, activeArrayKeys?: ReadonlySet<string>) => IrType | undefined;
+//# sourceMappingURL=storage-types.d.ts.map

package/dist/core/semantic/storage-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-types.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/storage-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAoCrD,eAAO,MAAM,mBAAmB,GAC9B,MAAM,MAAM,GAAG,SAAS,EACxB,SAAS,cAAc,KACtB,OAWF,CAAC;AAEF,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,EAC5C,OAAO,EAAE,cAAc,EACvB,eAAe,GAAE,WAAW,CAAC,MAAM,CAAqB,GACvD,OAAO,CAwCT;AA+OD,eAAO,MAAM,2BAA2B,GACtC,MAAM,MAAM,GAAG,SAAS,EACxB,SAAS,cAAc,EACvB,kBAAiB,WAAW,CAAC,MAAM,CAAqB,KACvD,MAAM,GAAG,SAiOX,CAAC"}

package/dist/core/semantic/storage-types.js

@@ -0,0 +1,344 @@
+import { isAwaitableIrType } from "@tsonic/frontend";
+import { getCanonicalRuntimeUnionMembers } from "./runtime-unions.js";
+import { resolveTypeAlias, splitRuntimeNullishUnionMembers, } from "./type-resolution.js";
+import { rebuildUnionTypePreservingCarrierFamily } from "./runtime-union-family-preservation.js";
+import { isBroadObjectSlotType } from "./broad-object-types.js";
+import { referenceTypeHasClrIdentity } from "./clr-type-identity.js";
+import { areIrTypesEquivalent } from "./type-equivalence.js";
+import { getContextualTypeVisitKey } from "./deterministic-type-keys.js";
+const SYSTEM_OBJECT_CLR_NAMES = new Set([
+    "System.Object",
+    "global::System.Object",
+]);
+const OBJECT_STORAGE_TYPE = {
+    kind: "referenceType",
+    name: "object",
+    resolvedClrType: "System.Object",
+};
+const typesEquivalent = (left, right, context) => areIrTypesEquivalent(left, right, context);
+const containsEquivalentType = (types, type, context) => types.some((candidate) => typesEquivalent(candidate, type, context));
+export const isObjectStorageType = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    const resolved = resolveTypeAlias(type, context);
+    return (resolved.kind === "referenceType" &&
+        (resolved.name === "object" ||
+            referenceTypeHasClrIdentity(resolved, SYSTEM_OBJECT_CLR_NAMES)));
+};
+export function shouldUseBroadObjectForUnionStorage(type, context, activeArrayKeys = new Set()) {
+    const split = splitRuntimeNullishUnionMembers(type);
+    const nonNullishMembers = split?.nonNullishMembers ?? type.types;
+    if (nonNullishMembers.length === 1) {
+        return isBroadObjectSlotType(nonNullishMembers[0], context);
+    }
+    if (nonNullishMembers.length < 2) {
+        return false;
+    }
+    const canonicalRuntimeMembers = getCanonicalRuntimeUnionMembers(rebuildUnionTypePreservingCarrierFamily(type, nonNullishMembers), context);
+    const runtimeMembers = canonicalRuntimeMembers && canonicalRuntimeMembers.length > 1
+        ? canonicalRuntimeMembers
+        : nonNullishMembers;
+    if (runtimeMembers.length < 2 ||
+        runtimeMembers.some((member) => isAwaitableIrType(member))) {
+        return false;
+    }
+    const normalizedMembers = [];
+    for (const member of runtimeMembers) {
+        const normalizedMember = normalizeRuntimeStorageType(member, context, activeArrayKeys) ?? member;
+        if (containsEquivalentType(normalizedMembers, normalizedMember, context)) {
+            continue;
+        }
+        normalizedMembers.push(normalizedMember);
+    }
+    return (normalizedMembers.length > 1 &&
+        normalizedMembers.some((member) => isBroadObjectSlotType(member, context)));
+}
+const isInScopeTypeParameter = (name, context) => context.typeParameters?.has(name) ?? false;
+const isRuntimeNullishMember = (type) => type.kind === "primitiveType" &&
+    (type.name === "null" || type.name === "undefined");
+const getBareUnconstrainedTypeParameter = (type, context) => {
+    if (type.kind !== "typeParameterType") {
+        return undefined;
+    }
+    const constraintKind = context.typeParamConstraints?.get(type.name) ?? "unconstrained";
+    if (constraintKind !== "unconstrained") {
+        return undefined;
+    }
+    if (isInScopeTypeParameter(type.name, context)) {
+        return context.eraseNullableUnconstrainedTypeParameterStorage
+            ? type.name
+            : undefined;
+    }
+    return type.name;
+};
+const normalizeOutOfScopeTypeParameters = (type, context, visited = new WeakSet()) => {
+    if (typeof type === "object" && type !== null) {
+        if (visited.has(type)) {
+            return type;
+        }
+        visited.add(type);
+    }
+    if (type.kind === "referenceType") {
+        const resolvedAlias = resolveTypeAlias(type, context, {
+            preserveObjectTypeAliases: true,
+        });
+        if (resolvedAlias.kind === "unionType" &&
+            resolvedAlias.runtimeCarrierFamilyKey) {
+            if (!type.typeArguments || type.typeArguments.length === 0) {
+                return type;
+            }
+            const normalizedTypeArguments = type.typeArguments.map((typeArgument) => normalizeOutOfScopeTypeParameters(typeArgument, context, visited));
+            return normalizedTypeArguments.every((typeArgument, index) => typesEquivalent(typeArgument, type.typeArguments?.[index] ?? typeArgument, context))
+                ? type
+                : {
+                    ...type,
+                    typeArguments: normalizedTypeArguments,
+                };
+        }
+    }
+    const resolved = resolveTypeAlias(type, context, {
+        preserveObjectTypeAliases: true,
+    });
+    switch (resolved.kind) {
+        case "typeParameterType":
+            return isInScopeTypeParameter(resolved.name, context)
+                ? resolved
+                : OBJECT_STORAGE_TYPE;
+        case "arrayType": {
+            const normalizedElementType = normalizeOutOfScopeTypeParameters(resolved.elementType, context, visited);
+            return typesEquivalent(normalizedElementType, resolved.elementType, context)
+                ? resolved
+                : {
+                    ...resolved,
+                    elementType: normalizedElementType,
+                };
+        }
+        case "dictionaryType": {
+            const normalizedKeyType = normalizeOutOfScopeTypeParameters(resolved.keyType, context, visited);
+            const normalizedValueType = normalizeOutOfScopeTypeParameters(resolved.valueType, context, visited);
+            return typesEquivalent(normalizedKeyType, resolved.keyType, context) &&
+                typesEquivalent(normalizedValueType, resolved.valueType, context)
+                ? resolved
+                : {
+                    ...resolved,
+                    keyType: normalizedKeyType,
+                    valueType: normalizedValueType,
+                };
+        }
+        case "tupleType": {
+            const normalizedElementTypes = resolved.elementTypes.map((elementType) => normalizeOutOfScopeTypeParameters(elementType, context, visited));
+            return normalizedElementTypes.every((elementType, index) => typesEquivalent(elementType, resolved.elementTypes[index] ?? elementType, context))
+                ? resolved
+                : {
+                    ...resolved,
+                    elementTypes: normalizedElementTypes,
+                };
+        }
+        case "referenceType": {
+            if (!resolved.typeArguments || resolved.typeArguments.length === 0) {
+                return resolved;
+            }
+            const normalizedTypeArguments = resolved.typeArguments.map((typeArg) => normalizeOutOfScopeTypeParameters(typeArg, context, visited));
+            return normalizedTypeArguments.every((typeArg, index) => typesEquivalent(typeArg, resolved.typeArguments?.[index] ?? typeArg, context))
+                ? resolved
+                : {
+                    ...resolved,
+                    typeArguments: normalizedTypeArguments,
+                };
+        }
+        case "unionType": {
+            const normalizedMembers = resolved.types.map((member) => normalizeOutOfScopeTypeParameters(member, context, visited));
+            return normalizedMembers.every((member, index) => typesEquivalent(member, resolved.types[index] ?? member, context))
+                ? resolved
+                : {
+                    ...resolved,
+                    types: normalizedMembers,
+                };
+        }
+        case "functionType": {
+            const normalizedParameters = resolved.parameters.map((parameter) => {
+                if (!parameter.type) {
+                    return parameter;
+                }
+                const normalizedParameterType = normalizeOutOfScopeTypeParameters(parameter.type, context, visited);
+                return typesEquivalent(normalizedParameterType, parameter.type, context)
+                    ? parameter
+                    : {
+                        ...parameter,
+                        type: normalizedParameterType,
+                    };
+            });
+            const normalizedReturnType = normalizeOutOfScopeTypeParameters(resolved.returnType, context, visited);
+            return normalizedParameters.every((parameter, index) => typesEquivalent(parameter.type ?? { kind: "voidType" }, resolved.parameters[index]?.type ?? { kind: "voidType" }, context)) &&
+                typesEquivalent(normalizedReturnType, resolved.returnType, context)
+                ? resolved
+                : {
+                    ...resolved,
+                    parameters: normalizedParameters,
+                    returnType: normalizedReturnType,
+                };
+        }
+        case "intersectionType": {
+            const normalizedMembers = resolved.types.map((member) => normalizeOutOfScopeTypeParameters(member, context, visited));
+            return normalizedMembers.every((member, index) => typesEquivalent(member, resolved.types[index] ?? member, context))
+                ? resolved
+                : {
+                    ...resolved,
+                    types: normalizedMembers,
+                };
+        }
+        default:
+            return resolved;
+    }
+};
+export const normalizeRuntimeStorageType = (type, context, activeArrayKeys = new Set()) => {
+    if (!type) {
+        return undefined;
+    }
+    if (type.kind === "referenceType") {
+        const resolvedAlias = resolveTypeAlias(type, context, {
+            preserveObjectTypeAliases: true,
+        });
+        if (resolvedAlias.kind === "unionType" &&
+            resolvedAlias.runtimeCarrierFamilyKey) {
+            if (!type.typeArguments || type.typeArguments.length === 0) {
+                return type;
+            }
+            const normalizedTypeArguments = type.typeArguments.map((typeArgument) => normalizeOutOfScopeTypeParameters(typeArgument, context));
+            return normalizedTypeArguments.every((typeArgument, index) => typesEquivalent(typeArgument, type.typeArguments?.[index] ?? typeArgument, context))
+                ? type
+                : {
+                    ...type,
+                    typeArguments: normalizedTypeArguments,
+                };
+        }
+    }
+    const resolved = normalizeOutOfScopeTypeParameters(type, context);
+    if (resolved.kind === "unknownType" ||
+        resolved.kind === "anyType" ||
+        resolved.kind === "objectType" ||
+        (resolved.kind === "referenceType" && resolved.name === "object")) {
+        return OBJECT_STORAGE_TYPE;
+    }
+    if (resolved.kind === "literalType") {
+        switch (typeof resolved.value) {
+            case "string":
+                return { kind: "primitiveType", name: "string" };
+            case "number":
+                return { kind: "primitiveType", name: "number" };
+            case "boolean":
+                return { kind: "primitiveType", name: "boolean" };
+            default:
+                return resolved;
+        }
+    }
+    if (resolved.kind === "arrayType") {
+        const arrayKey = getContextualTypeVisitKey(resolved, context);
+        if (activeArrayKeys.has(arrayKey)) {
+            return resolved;
+        }
+        const nextActive = new Set(activeArrayKeys);
+        nextActive.add(arrayKey);
+        const normalizedElementType = normalizeRuntimeStorageType(resolved.elementType, context, nextActive) ??
+            resolved.elementType;
+        return typesEquivalent(normalizedElementType, resolved.elementType, context)
+            ? resolved
+            : {
+                ...resolved,
+                elementType: normalizedElementType,
+            };
+    }
+    if (resolved.kind === "unionType") {
+        if (shouldUseBroadObjectForUnionStorage(resolved, context, activeArrayKeys)) {
+            const split = splitRuntimeNullishUnionMembers(resolved);
+            const nullishMembers = resolved.types.filter(isRuntimeNullishMember);
+            return split?.hasRuntimeNullish
+                ? rebuildUnionTypePreservingCarrierFamily(resolved, [
+                    OBJECT_STORAGE_TYPE,
+                    ...nullishMembers,
+                ])
+                : OBJECT_STORAGE_TYPE;
+        }
+        const topLevelSplit = splitRuntimeNullishUnionMembers(resolved);
+        const topLevelNonNullishMembers = topLevelSplit?.nonNullishMembers ?? resolved.types;
+        const canonicalRuntimeMembers = topLevelNonNullishMembers.length > 1
+            ? getCanonicalRuntimeUnionMembers(rebuildUnionTypePreservingCarrierFamily(resolved, topLevelNonNullishMembers), context)
+            : undefined;
+        if (canonicalRuntimeMembers && canonicalRuntimeMembers.length > 1) {
+            const normalizedCanonicalMembers = [];
+            for (const member of canonicalRuntimeMembers) {
+                const normalizedMember = normalizeRuntimeStorageType(member, context, activeArrayKeys) ??
+                    member;
+                if (containsEquivalentType(normalizedCanonicalMembers, normalizedMember, context)) {
+                    continue;
+                }
+                normalizedCanonicalMembers.push(normalizedMember);
+            }
+            if (!topLevelSplit?.hasRuntimeNullish) {
+                return rebuildUnionTypePreservingCarrierFamily(resolved, normalizedCanonicalMembers);
+            }
+            const directNullishMembers = resolved.types.filter(isRuntimeNullishMember);
+            return rebuildUnionTypePreservingCarrierFamily(resolved, [
+                ...normalizedCanonicalMembers,
+                ...directNullishMembers,
+            ]);
+        }
+        const split = splitRuntimeNullishUnionMembers(resolved);
+        if (split) {
+            const normalizedNonNullishMembers = split.nonNullishMembers.map((member) => normalizeRuntimeStorageType(member, context, activeArrayKeys) ??
+                member);
+            const dedupedNormalizedNonNullishMembers = [];
+            for (const member of normalizedNonNullishMembers) {
+                if (containsEquivalentType(dedupedNormalizedNonNullishMembers, member, context)) {
+                    continue;
+                }
+                dedupedNormalizedNonNullishMembers.push(member);
+            }
+            if (dedupedNormalizedNonNullishMembers.length === 1) {
+                const [normalizedSingleMember] = dedupedNormalizedNonNullishMembers;
+                const [originalSingleMember] = split.nonNullishMembers;
+                if (!normalizedSingleMember) {
+                    return resolved;
+                }
+                const nullishMembers = resolved.types.filter(isRuntimeNullishMember);
+                if (originalSingleMember &&
+                    getBareUnconstrainedTypeParameter(originalSingleMember, context)) {
+                    return nullishMembers.length === 0
+                        ? OBJECT_STORAGE_TYPE
+                        : {
+                            kind: "unionType",
+                            types: [OBJECT_STORAGE_TYPE, ...nullishMembers],
+                        };
+                }
+                return nullishMembers.length === 0
+                    ? normalizedSingleMember
+                    : rebuildUnionTypePreservingCarrierFamily(resolved, [
+                        normalizedSingleMember,
+                        ...nullishMembers,
+                    ]);
+            }
+        }
+        if (!split || split.nonNullishMembers.length !== 1) {
+            return resolved;
+        }
+        const nonNullishMember = split.nonNullishMembers[0];
+        if (!nonNullishMember) {
+            return resolved;
+        }
+        if (getBareUnconstrainedTypeParameter(nonNullishMember, context)) {
+            return {
+                kind: "unionType",
+                types: resolved.types.map((member) => isRuntimeNullishMember(member) ? member : OBJECT_STORAGE_TYPE),
+            };
+        }
+        const normalizedNonNullishMember = normalizeRuntimeStorageType(nonNullishMember, context, activeArrayKeys) ??
+            nonNullishMember;
+        if (typesEquivalent(normalizedNonNullishMember, nonNullishMember, context)) {
+            return resolved;
+        }
+        return rebuildUnionTypePreservingCarrierFamily(resolved, resolved.types.map((member) => isRuntimeNullishMember(member) ? member : normalizedNonNullishMember));
+    }
+    return resolved;
+};
+//# sourceMappingURL=storage-types.js.map