tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-object-literals.d.ts

@@ -0,0 +1,14 @@
+import { type Node, type PropertyAssignment, type ShorthandPropertyAssignment } from './ast.js';
+import { type Checker } from './checker.js';
+import { CheckMode, ObjectFlags, type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
+export declare function checkObjectLiteral(c: Checker, node: Node, checkMode: CheckMode): Type;
+export declare function checkPropertyAssignment(c: Checker, node: PropertyAssignment, checkMode: CheckMode): Type;
+export declare function checkShorthandPropertyAssignment(c: Checker, node: ShorthandPropertyAssignment, inDestructuringPattern: boolean, checkMode: CheckMode): Type;
+/** Reports earlier properties that a spread always overwrites. */
+export declare function checkSpreadPropOverrides(c: Checker, t: Type, props: Map<string, Symbol>, spread: Node): void;
+/**
+ * The type of spreading `right` after `left`. Object literals fold their spreads left to right,
+ * with `left` the result so far.
+ */
+export declare function getSpreadType(c: Checker, leftIn: Type, rightIn: Type, symbol: Symbol | undefined, objectFlags: ObjectFlags, readonly: boolean): Type;

package/dist/api/compiler/checker-object-literals.js

@@ -0,0 +1,483 @@
+// Object literals: their types, computed members and spreads.
+import { checkGrammarObjectLiteralOfExpression } from './checker-grammar.js';
+import { getExpression, getName, getProperties, getSymbol, getText, getType, } from './ast.js';
+import { isAssignmentTarget } from './binder-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { emptyIndexInfos, emptySignatures, IndexInfo, } from './checker-types.js';
+import { checkCrossProductUnion, createAnonymousType, getIntersectionType, getUnionType, getUnionTypeEx, isErrorType, mapType, typesOf, } from './checker-type-factory.js';
+import { getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfType, getPropertyOfType, getReducedType, keepPropertiesOnly, scannedLiteralPropertiesLimit, } from './checker-members.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { addOptionality, getTypeOfSymbol, removeMissingOrUndefinedType } from './checker-symbol-types.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { isGenericMappedType, isGenericObjectType, isTypeAssignableToKindEx } from './checker-type-operators.js';
+import { isTypeAssignableTo } from './relations.js';
+import { getPropertyNameFromType, isNumericLiteralName, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { getSpreadSymbol, isSpreadableProperty, isValidSpreadType, hasDefaultValue } from './checker-destructuring.js';
+import { checkComputedPropertyName, checkExpressionEx, checkExpressionForMutableLocationEx, checkTypeAssignableToAndOptionallyElaborate, isConstContext, } from './checker-expressions.js';
+import { checkFunctionExpressionOrObjectLiteralMethod, getTypeOfObjectLiteralMethod, isContextSensitive, } from './checker-functions.js';
+import { getApparentTypeOfContextualType, getInferenceContext, popContextualType, pushCachedContextualType, } from './checker-contextual.js';
+import { addIntraExpressionInferenceSite } from './checker-inference.js';
+import { isEmptyObjectType } from './checker-type-factory.js';
+import { getTypeOfExpandoObjectLiteral, isJSObjectLiteral } from './checker-javascript.js';
+import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, internalSymbolNamePrefix, setDeclarations, } from './symbol.js';
+/** Builds the type of the members collected since the last spread. */
+class ObjectLiteralBuilder {
+    node;
+    inDestructuringPattern;
+    members = new Map();
+    /** Members in order, including those with computed names that only feed index signatures. */
+    properties = [];
+    objectFlags = 8192 /* ObjectFlags.FreshLiteral */;
+    patternWithComputedProperties = false;
+    /** An object literal in a JavaScript file without a contextual type allows unknown members. */
+    isJSLiteral = false;
+    hasComputedString = false;
+    hasComputedNumber = false;
+    hasComputedSymbol = false;
+    /** Where the members since the last spread start in `properties`. */
+    offset = 0;
+    constructor(node, inDestructuringPattern) {
+        this.node = node;
+        this.inDestructuringPattern = inDestructuringPattern;
+    }
+    createType(c) {
+        let indexInfos = emptyIndexInfos;
+        const isReadonly = isConstContext(c, this.node);
+        if (this.hasComputedString || this.hasComputedNumber || this.hasComputedSymbol) {
+            // Index signatures cover the members since the last spread.
+            const properties = this.properties.slice(this.offset);
+            indexInfos = [];
+            if (this.hasComputedString)
+                indexInfos.push(getObjectLiteralIndexInfo(c, isReadonly, properties, c.stringType));
+            if (this.hasComputedNumber)
+                indexInfos.push(getObjectLiteralIndexInfo(c, isReadonly, properties, c.numberType));
+            if (this.hasComputedSymbol)
+                indexInfos.push(getObjectLiteralIndexInfo(c, isReadonly, properties, c.esSymbolType));
+        }
+        const result = createAnonymousType(c, getSymbol(this.node), this.members, emptySignatures, emptySignatures, indexInfos);
+        result.objectFlags |= this.objectFlags | 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+        if (this.isJSLiteral)
+            result.objectFlags |= 4096 /* ObjectFlags.JSLiteral */;
+        if (this.patternWithComputedProperties)
+            result.objectFlags |= 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */;
+        if (this.inDestructuringPattern)
+            c.patternForType.set(result, this.node);
+        // A literal of a few properties keeps them as a list; a lookup by name compares their names.
+        keepPropertiesOnly(c, result, this.members, scannedLiteralPropertiesLimit);
+        return result;
+    }
+    reset() {
+        this.members = new Map();
+        this.properties = [];
+        this.offset = 0;
+        this.hasComputedString = false;
+        this.hasComputedNumber = false;
+        this.hasComputedSymbol = false;
+    }
+}
+export function checkObjectLiteral(c, node, checkMode) {
+    const expandoType = getTypeOfExpandoObjectLiteral(c, node);
+    if (expandoType !== undefined)
+        return expandoType;
+    const inDestructuringPattern = isAssignmentTarget(node);
+    checkGrammarObjectLiteralOfExpression(c, node, inDestructuringPattern);
+    const allProperties = c.strictNullChecks ? new Map() : undefined;
+    // The members' contextual types come from the literal's, computed once.
+    pushCachedContextualType(c, node);
+    const inConstContext = isConstContext(c, node);
+    const checkFlags = inConstContext ? 8 /* CheckFlags.Readonly */ : 0;
+    const builder = new ObjectLiteralBuilder(node, inDestructuringPattern);
+    builder.isJSLiteral = isJSObjectLiteral(c, node);
+    const contextualType = getApparentTypeOfContextualType(c, node);
+    const contextualPattern = contextualType !== undefined ? c.patternForType.get(contextualType) : undefined;
+    const contextualTypeHasPattern = contextualPattern !== undefined &&
+        (contextualPattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
+            contextualPattern.kind === 211 /* SyntaxKind.ObjectLiteralExpression */);
+    let spread = c.emptyObjectType;
+    const elements = getProperties(node).nodes;
+    // Computed names are checked up front: a spread may bail out before the member is reached.
+    for (const e of elements) {
+        const name = getName(e);
+        if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            checkComputedPropertyName(c, name);
+    }
+    for (const memberDecl of elements) {
+        let member = getSymbolOfDeclaration(c, memberDecl);
+        const name = getName(memberDecl);
+        const computedNameType = name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */
+            ? checkComputedPropertyName(c, name)
+            : undefined;
+        if (memberDecl.kind === 303 /* SyntaxKind.PropertyAssignment */ ||
+            memberDecl.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ ||
+            memberDecl.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+            let t;
+            if (memberDecl.kind === 303 /* SyntaxKind.PropertyAssignment */)
+                t = checkPropertyAssignment(c, memberDecl, checkMode);
+            else if (memberDecl.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+                t = checkShorthandPropertyAssignment(c, memberDecl, inDestructuringPattern, checkMode);
+            else
+                t = getTypeOfObjectLiteralMethod(c, memberDecl, checkMode);
+            if ((checkMode & 2 /* CheckMode.Inferential */) !== 0 &&
+                (checkMode & 4 /* CheckMode.SkipContextSensitive */) === 0 &&
+                (memberDecl.kind === 303 /* SyntaxKind.PropertyAssignment */ || memberDecl.kind === 175 /* SyntaxKind.MethodDeclaration */) &&
+                isContextSensitive(c, memberDecl)) {
+                // Inferences flowing between context-sensitive members are made before fixing.
+                const inferenceContext = getInferenceContext(c, node);
+                if (inferenceContext !== undefined)
+                    addIntraExpressionInferenceSite(inferenceContext, memberDecl.kind === 303 /* SyntaxKind.PropertyAssignment */
+                        ? memberDecl.initializer
+                        : memberDecl, t);
+            }
+            if (member === undefined)
+                continue;
+            builder.objectFlags |= t.objectFlags & 458752 /* ObjectFlags.PropagatingFlags */;
+            const nameType = computedNameType !== undefined && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined;
+            const prop = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | member.flags, nameType !== undefined ? getPropertyNameFromType(nameType) : member.name, checkFlags | (nameType !== undefined ? 4096 /* CheckFlags.Late */ : 0));
+            const id = getSymbolId(prop);
+            if (nameType !== undefined)
+                c.symbolNameTypes.set(id, nameType);
+            // Defaults in assignment patterns make the property optional.
+            if (inDestructuringPattern && hasDefaultValue(memberDecl))
+                prop.flags |= 16777216 /* SymbolFlags.Optional */;
+            else if (contextualTypeHasPattern &&
+                (contextualType.objectFlags & 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */) === 0) {
+                // Properties defaulted in the binding pattern that implies the contextual type are optional.
+                const impliedProp = getPropertyOfType(c, contextualType, member.name);
+                if (impliedProp !== undefined)
+                    prop.flags |= impliedProp.flags & 16777216 /* SymbolFlags.Optional */;
+                else if (getIndexInfoOfType(c, contextualType, c.stringType) === undefined)
+                    c.error(getName(memberDecl), 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */, symbolToString(c, member), typeToString(c, contextualType));
+            }
+            copyDeclarations(prop, member);
+            prop.parent = member.parent;
+            prop.valueDeclaration = member.valueDeclaration;
+            c.symbolTypes.set(id, t);
+            c.symbolTargets.set(id, member);
+            member = prop;
+            if (allProperties !== undefined)
+                allProperties.set(prop.name, prop);
+        }
+        else if (memberDecl.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+            if (builder.properties.length > 0) {
+                spread = getSpreadType(c, spread, builder.createType(c), getSymbol(node), builder.objectFlags, inConstContext);
+                builder.reset();
+            }
+            const t = getReducedType(c, checkExpressionEx(c, getExpression(memberDecl), checkMode & 2 /* CheckMode.Inferential */));
+            if (isValidSpreadType(c, t)) {
+                const mergedType = tryMergeUnionOfObjectTypeAndEmptyObject(c, t, inConstContext);
+                if (allProperties !== undefined)
+                    checkSpreadPropOverrides(c, mergedType, allProperties, memberDecl);
+                builder.offset = builder.properties.length;
+                if (isErrorType(c, spread))
+                    continue;
+                spread = getSpreadType(c, spread, mergedType, getSymbol(node), builder.objectFlags, inConstContext);
+            }
+            else {
+                c.error(memberDecl, 830 /* Diagnostics.Spread_types_may_only_be_created_from_object_types */);
+                spread = c.errorType;
+            }
+            continue;
+        }
+        else {
+            // Accessors are checked like functions.
+            checkFunctionExpressionOrObjectLiteralMethod(c, memberDecl, checkMode);
+            if (member === undefined)
+                continue;
+            member = getMergedSymbol(c, member);
+        }
+        if (computedNameType !== undefined && (computedNameType.flags & 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */) === 0) {
+            if (isTypeAssignableTo(c, computedNameType, c.stringNumberSymbolType)) {
+                if (isTypeAssignableTo(c, computedNameType, c.numberType))
+                    builder.hasComputedNumber = true;
+                else if (isTypeAssignableTo(c, computedNameType, c.esSymbolType))
+                    builder.hasComputedSymbol = true;
+                else
+                    builder.hasComputedString = true;
+                if (inDestructuringPattern)
+                    builder.patternWithComputedProperties = true;
+            }
+        }
+        else
+            builder.members.set(member.name, member);
+        builder.properties.push(member);
+    }
+    popContextualType(c);
+    if (isErrorType(c, spread))
+        return c.errorType;
+    if (spread !== c.emptyObjectType) {
+        if (builder.properties.length > 0) {
+            spread = getSpreadType(c, spread, builder.createType(c), getSymbol(node), builder.objectFlags, inConstContext);
+            builder.reset();
+        }
+        // The raw empty object fed in at the start becomes a fresh empty literal unique to this site.
+        return mapType(c, spread, (t) => (t === c.emptyObjectType ? builder.createType(c) : t));
+    }
+    return builder.createType(c);
+}
+export function checkPropertyAssignment(c, node, checkMode) {
+    if (node.name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        checkComputedPropertyName(c, node.name);
+    const initializerType = checkExpressionForMutableLocationEx(c, node.initializer, checkMode);
+    const typeNode = getType(node);
+    if (typeNode === undefined)
+        return initializerType;
+    const t = getTypeFromTypeNode(c, typeNode);
+    checkTypeAssignableToAndOptionallyElaborate(c, initializerType, t, node, node.initializer);
+    return t;
+}
+export function checkShorthandPropertyAssignment(c, node, inDestructuringPattern, checkMode) {
+    const expr = (inDestructuringPattern ? undefined : node.objectAssignmentInitializer) ?? node.name;
+    const expressionType = checkExpressionForMutableLocationEx(c, expr, checkMode);
+    const typeNode = getType(node);
+    if (typeNode === undefined)
+        return expressionType;
+    const t = getTypeFromTypeNode(c, typeNode);
+    checkTypeAssignableToAndOptionallyElaborate(c, expressionType, t, node, expr);
+    return t;
+}
+function getObjectLiteralIndexInfo(c, isReadonly, properties, keyType) {
+    const propTypes = [];
+    const components = [];
+    for (const prop of properties) {
+        if ((keyType === c.stringType && !isSymbolWithSymbolName(c, prop)) ||
+            (keyType === c.numberType && isSymbolWithNumericName(c, prop)) ||
+            (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))) {
+            propTypes.push(getTypeOfSymbol(c, prop));
+            if (isSymbolWithComputedName(prop))
+                components.push(prop.declaration);
+        }
+    }
+    const unionType = propTypes.length !== 0
+        ? getUnionTypeEx(c, propTypes, 2 /* UnionReduction.Subtype */, undefined, undefined)
+        : c.undefinedType;
+    return new IndexInfo(keyType, unionType, isReadonly, undefined, components);
+}
+function getFirstDeclarationName(symbol) {
+    return declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
+}
+function isSymbolWithSymbolName(c, symbol) {
+    if (symbol.name.startsWith(internalSymbolNamePrefix + '@'))
+        return true;
+    const name = getFirstDeclarationName(symbol);
+    return (name !== undefined &&
+        name.kind === 168 /* SyntaxKind.ComputedPropertyName */ &&
+        isTypeAssignableToKindEx(c, checkComputedPropertyName(c, name), 512 /* TypeFlags.ESSymbol */, false));
+}
+function isSymbolWithNumericName(c, symbol) {
+    if (isNumericLiteralName(symbol.name))
+        return true;
+    const name = getFirstDeclarationName(symbol);
+    if (name === undefined)
+        return false;
+    switch (name.kind) {
+        case 168 /* SyntaxKind.ComputedPropertyName */:
+            return isTypeAssignableToKindEx(c, checkComputedPropertyName(c, name), 67648 /* TypeFlags.NumberLike */, false);
+        case 79 /* SyntaxKind.Identifier */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+            return isNumericLiteralName(getText(name));
+    }
+    return false;
+}
+function isSymbolWithComputedName(symbol) {
+    const name = getFirstDeclarationName(symbol);
+    return name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */;
+}
+/** Reports earlier properties that a spread always overwrites. */
+export function checkSpreadPropOverrides(c, t, props, spread) {
+    for (const right of getPropertiesOfType(c, t)) {
+        if ((right.flags & 16777216 /* SymbolFlags.Optional */) !== 0 || (right.checkFlags & 48 /* CheckFlags.Partial */) !== 0)
+            continue;
+        const left = props.get(right.name);
+        if (left === undefined)
+            continue;
+        const diagnostic = c.error(left.valueDeclaration, 915 /* Diagnostics.X_0_is_specified_more_than_once_so_this_usage_will_be_overwritten */, left.name);
+        diagnostic.addRelatedInfo(createDiagnosticForNode(spread, 917 /* Diagnostics.This_spread_always_overwrites_this_property */, []));
+    }
+}
+// ---- Spread types
+/**
+ * The type of spreading `right` after `left`. Object literals fold their spreads left to right,
+ * with `left` the result so far.
+ */
+export function getSpreadType(c, leftIn, rightIn, symbol, objectFlags, readonly) {
+    let left = leftIn;
+    let right = rightIn;
+    if ((left.flags & 1 /* TypeFlags.Any */) !== 0 || (right.flags & 1 /* TypeFlags.Any */) !== 0)
+        return c.anyType;
+    if ((left.flags & 2 /* TypeFlags.Unknown */) !== 0 || (right.flags & 2 /* TypeFlags.Unknown */) !== 0)
+        return c.unknownType;
+    if ((left.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return right;
+    if ((right.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return left;
+    left = tryMergeUnionOfObjectTypeAndEmptyObject(c, left, readonly);
+    if ((left.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        if (!checkCrossProductUnion(c, [left, right]))
+            return c.errorType;
+        const r = right;
+        return mapType(c, left, (t) => getSpreadType(c, t, r, symbol, objectFlags, readonly));
+    }
+    right = tryMergeUnionOfObjectTypeAndEmptyObject(c, right, readonly);
+    if ((right.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        if (!checkCrossProductUnion(c, [left, right]))
+            return c.errorType;
+        const l = left;
+        return mapType(c, right, (t) => getSpreadType(c, l, t, symbol, objectFlags, readonly));
+    }
+    if ((right.flags &
+        (8448 /* TypeFlags.BooleanLike */ |
+            67648 /* TypeFlags.NumberLike */ |
+            4224 /* TypeFlags.BigIntLike */ |
+            12583968 /* TypeFlags.StringLike */ |
+            98304 /* TypeFlags.EnumLike */ |
+            131072 /* TypeFlags.NonPrimitive */ |
+            2097152 /* TypeFlags.Index */)) !==
+        0)
+        return left;
+    if (isGenericObjectType(c, left) || isGenericObjectType(c, right)) {
+        if (isEmptyObjectType(c, left))
+            return right;
+        // `T & { a: string }` spread with `{ b: string }` merges into `T & { a: string, b: string }`.
+        if ((left.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+            const types = typesOf(left);
+            const lastLeft = types[types.length - 1];
+            if (isNonGenericObjectType(c, lastLeft) && isNonGenericObjectType(c, right)) {
+                const newTypes = types.slice();
+                newTypes[newTypes.length - 1] = getSpreadType(c, lastLeft, right, symbol, objectFlags, readonly);
+                return getIntersectionType(c, newTypes);
+            }
+        }
+        return getIntersectionType(c, [left, right]);
+    }
+    const members = new Map();
+    const skippedPrivateMembers = new Set();
+    const indexInfos = left === c.emptyObjectType ? getIndexInfosOfType(c, right) : getUnionIndexInfos(c, [left, right]);
+    for (const rightProp of getPropertiesOfType(c, right)) {
+        if ((getDeclarationModifierFlagsFromSymbol(c, rightProp, false) &
+            (2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */)) !==
+            0)
+            skippedPrivateMembers.add(rightProp.name);
+        else if (isSpreadableProperty(rightProp))
+            members.set(rightProp.name, getSpreadSymbol(c, rightProp, readonly));
+    }
+    for (const leftProp of getPropertiesOfType(c, left)) {
+        if (skippedPrivateMembers.has(leftProp.name) || !isSpreadableProperty(leftProp))
+            continue;
+        const rightProp = members.get(leftProp.name);
+        if (rightProp === undefined) {
+            members.set(leftProp.name, getSpreadSymbol(c, leftProp, readonly));
+            continue;
+        }
+        if ((rightProp.flags & 16777216 /* SymbolFlags.Optional */) === 0)
+            continue;
+        const result = c.newSymbol(4 /* SymbolFlags.Property */ | (leftProp.flags & 16777216 /* SymbolFlags.Optional */), leftProp.name);
+        const id = getSymbolId(result);
+        // Spreading into the same type is common, as with options bags; skip the subtype reduction then.
+        const leftType = getTypeOfSymbol(c, leftProp);
+        const leftTypeWithoutUndefined = removeMissingOrUndefinedType(c, leftType);
+        const rightTypeWithoutUndefined = removeMissingOrUndefinedType(c, getTypeOfSymbol(c, rightProp));
+        c.symbolTypes.set(id, leftTypeWithoutUndefined === rightTypeWithoutUndefined
+            ? leftType
+            : getUnionTypeEx(c, [leftType, rightTypeWithoutUndefined], 2 /* UnionReduction.Subtype */, undefined, undefined));
+        c.symbolLeftSpreads.set(id, leftProp);
+        c.symbolRightSpreads.set(id, rightProp);
+        setDeclarations(result, getDeclarations(leftProp).concat(getDeclarations(rightProp)));
+        c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(leftProp)));
+        members.set(leftProp.name, result);
+    }
+    const spreadIndexInfos = [];
+    for (const info of indexInfos)
+        spreadIndexInfos.push(getIndexInfoWithReadonly(info, readonly));
+    const spread = createAnonymousType(c, symbol, members, [], [], spreadIndexInfos);
+    spread.objectFlags |=
+        128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */ | 4194304 /* ObjectFlags.ContainsSpread */ | objectFlags;
+    keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
+    return spread;
+}
+function getIndexInfoWithReadonly(info, readonly) {
+    return info.isReadonly !== readonly
+        ? new IndexInfo(info.keyType, info.valueType, readonly, info.declaration, info.components)
+        : info;
+}
+function getUnionIndexInfos(c, types) {
+    const result = [];
+    for (const info of getIndexInfosOfType(c, types[0])) {
+        const indexType = info.keyType;
+        const valueTypes = [];
+        let isReadonly = false;
+        let all = true;
+        for (const t of types) {
+            const typeInfo = getIndexInfoOfType(c, t, indexType);
+            if (typeInfo === undefined) {
+                all = false;
+                break;
+            }
+            valueTypes.push(getIndexTypeOfType(c, t, indexType));
+            if (typeInfo.isReadonly)
+                isReadonly = true;
+        }
+        if (!all)
+            continue;
+        result.push(new IndexInfo(indexType, getUnionType(c, valueTypes), isReadonly, undefined, []));
+    }
+    return result;
+}
+function isNonGenericObjectType(c, t) {
+    return (t.flags & 1048576 /* TypeFlags.Object */) !== 0 && !isGenericMappedType(c, t);
+}
+function isEmptyObjectTypeOrSpreadsIntoEmptyObject(c, t) {
+    return (isEmptyObjectType(c, t) ||
+        (t.flags &
+            (8 /* TypeFlags.Null */ |
+                4 /* TypeFlags.Undefined */ |
+                8448 /* TypeFlags.BooleanLike */ |
+                67648 /* TypeFlags.NumberLike */ |
+                4224 /* TypeFlags.BigIntLike */ |
+                12583968 /* TypeFlags.StringLike */ |
+                98304 /* TypeFlags.EnumLike */ |
+                131072 /* TypeFlags.NonPrimitive */ |
+                2097152 /* TypeFlags.Index */)) !==
+            0);
+}
+/** A union of one object type and types that spread to nothing, spread as that object made optional. */
+function tryMergeUnionOfObjectTypeAndEmptyObject(c, t, readonly) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return t;
+    const types = typesOf(t);
+    let firstType;
+    let emptyType;
+    for (const u of types) {
+        if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(c, u)) {
+            if (emptyType === undefined && isEmptyObjectType(c, u))
+                emptyType = u;
+        }
+        else if (firstType === undefined)
+            firstType = u;
+        else
+            return t;
+    }
+    if (firstType === undefined)
+        return emptyType ?? c.emptyObjectType;
+    const members = new Map();
+    for (const prop of getPropertiesOfType(c, firstType)) {
+        if ((getDeclarationModifierFlagsFromSymbol(c, prop, false) & (2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */)) !==
+            0)
+            continue;
+        if (!isSpreadableProperty(prop))
+            continue;
+        const isSetonlyAccessor = (prop.flags & 65536 /* SymbolFlags.SetAccessor */) !== 0 && (prop.flags & 32768 /* SymbolFlags.GetAccessor */) === 0;
+        const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | 16777216 /* SymbolFlags.Optional */, prop.name, (prop.checkFlags & 4096 /* CheckFlags.Late */) | (readonly ? 8 /* CheckFlags.Readonly */ : 0));
+        const id = getSymbolId(result);
+        c.symbolTypes.set(id, isSetonlyAccessor ? c.undefinedType : addOptionality(c, getTypeOfSymbol(c, prop), true, true));
+        copyDeclarations(result, prop);
+        c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
+        c.symbolSyntheticOrigins.set(id, prop);
+        members.set(prop.name, result);
+    }
+    const spread = createAnonymousType(c, firstType.symbol, members, [], [], getIndexInfosOfType(c, firstType));
+    spread.objectFlags |= 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
+    return spread;
+}

package/dist/api/compiler/checker-operators.d.ts

@@ -0,0 +1,33 @@
+import { type BinaryExpression, type ConditionalExpression, type Node, type PostfixUnaryExpression, type PrefixUnaryExpression } from './ast.js';
+import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type Checker } from './checker.js';
+import { CheckMode, type Signature, type Type, TypeFlags } from './checker-types.js';
+export declare function checkPrefixUnaryExpression(c: Checker, node: PrefixUnaryExpression): Type;
+export declare function checkPostfixUnaryExpression(c: Checker, node: PostfixUnaryExpression): Type;
+export declare function checkDeleteExpression(c: Checker, node: Node): Type;
+/** Reports a grammar error unless the file already has syntax errors. */
+export declare function grammarErrorOnNode(c: Checker, node: Node, message: DiagnosticMessage, ...args: string[]): boolean;
+export declare function allTypesAssignableToKind(c: Checker, t: Type, kind: TypeFlags): boolean;
+export declare function errorAndMaybeSuggestAwait(c: Checker, location: Node, maybeMissingAwait: boolean, message: DiagnosticMessage, args: string[]): Diagnostic;
+/** Whether `expr` can be assigned to; reports `invalidReference` or `invalidOptionalChain` otherwise. */
+export declare function checkReferenceExpression(c: Checker, expr: Node, invalidReference: DiagnosticMessage, invalidOptionalChain: DiagnosticMessage): boolean;
+/** `node` without parentheses, type assertions, `satisfies` and non-null assertions. */
+export declare function skipOuterExpressions(nodeIn: Node): Node;
+export declare function checkBinaryExpression(c: Checker, node: BinaryExpression, checkMode: CheckMode): Type;
+export declare function isTypeEqualityComparableTo(c: Checker, source: Type, target: Type): boolean;
+/** The signature of `right[Symbol.hasInstance]` that `left instanceof right` calls, if any. */
+export declare function resolveInstanceofExpression(c: Checker, node: BinaryExpression, checkMode: CheckMode): Signature;
+export declare function getSymbolHasInstanceMethodOfObjectType(c: Checker, t: Type): Type | undefined;
+/** The member name of a well-known symbol such as `Symbol.iterator`. */
+export declare function getPropertyNameForKnownSymbolName(c: Checker, name: string): string;
+export declare function removeDefinitelyFalsyTypes(c: Checker, t: Type): Type;
+/** Reports tests of `void` and of expressions that are syntactically always truthy or falsy. */
+export declare function checkTruthinessOfType(c: Checker, t: Type, node: Node): Type;
+export declare function checkConditionalExpression(c: Checker, node: ConditionalExpression, checkMode: CheckMode): Type;
+export declare function checkTruthinessExpression(c: Checker, node: Node, checkMode: CheckMode): Type;
+/**
+ * Reports conditions on functions and promises that are always defined and not used in `body`,
+ * which usually means a missing call or `await`. Only under strictNullChecks.
+ */
+export declare function checkTestingKnownTruthyType(c: Checker, condExpr: Node, condType: Type, body: Node | undefined): void;
+export declare function isTypeAssertion(node: Node): boolean;