tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-destructuring.js

@@ -0,0 +1,584 @@
+// Destructuring: types of binding elements and the types implied by binding patterns.
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { checkGrammarRestTrailingComma } from './checker-grammar.js';
+import { markDestructuredPropertyAsReferenced } from './checker-unused.js';
+import { getElements, getInitializer, getName, getProperties, getSymbol, getType, getFlowNode, StringLiteral, ParenthesizedExpression, ElementAccessExpression, } from './ast.js';
+import { isLeftHandSideExpression } from './ast-utilities.js';
+import { getFlowTypeOfReference, getDestructuringPropertyName, getTypeOfInitializer } from './checker-narrowing.js';
+import { getRootDeclaration, isClassLike, isPartOfParameterDeclaration, isPrivateIdentifierClassElementDeclaration, } from './binder-utilities.js';
+import { getSymbolId } from './symbol.js';
+import { TupleElementInfo, } from './checker-types.js';
+import { cloneTypeReference, createAnonymousType, createArrayType, createTupleTypeEx, getElementTypes, getTypeReferenceArity, tupleTargetOf, everyType, filterType, getNumberLiteralType, getUnionType, getUnionTypeEx, isTupleType, mapType, newIndexInfo, someType, typesOf, } from './checker-type-factory.js';
+import { getIndexedAccessTypeEx, getIndexedAccessTypeOrUndefinedEx, getLiteralTypeFromProperty, getLiteralTypeFromPropertyName, isGenericIndexType, isGenericObjectType, } from './checker-type-operators.js';
+import { getBaseConstraintOfType, getBaseConstraintOrType, mapToBaseConstraintOrType, getDeclarationModifierFlagsFromSymbol, getReducedType, getIndexInfosOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertyOfType, isArrayLikeType, } from './checker-members.js';
+import { getGlobalTypeAliasSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { getTypeForVariableLikeDeclaration, getTypeOfSymbol, addOptionality, getWidenedLiteralTypeForInitializer, widenTypeInferredFromInitializer, isReadonlySymbol, reportImplicitAny, declarationBelongsToPrivateAmbientMember, isOptionalDeclaration, } from './checker-symbol-types.js';
+import { getTypeAliasInstantiation } from './checker-type-nodes.js';
+import { isTypeAssignableTo } from './relations.js';
+import { checkDeclarationInitializer, checkExpression, checkExpressionCached, checkExpressionEx, checkNonNullType, checkTypeAssignableToAndOptionallyElaborate, } from './checker-expressions.js';
+import { checkIteratedTypeOrElementType, createIterableType } from './checker-iteration.js';
+import { ScriptTarget } from './options.js';
+import { checkBinaryExpression, checkReferenceExpression, removeDefinitelyFalsyTypes } from './checker-operators.js';
+import { getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-flow.js';
+import { sliceTupleType } from './checker-signatures.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
+import { checkPropertyAccessibility } from './checker-property-access.js';
+function isBindingPatternNode(node) {
+    return (node !== undefined &&
+        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+}
+/** The type of a binding element, from the type of the declaration it destructures. */
+export function getTypeForBindingElement(c, declaration) {
+    const pattern = declaration.parent;
+    const checkMode = declaration.dotDotDotToken !== undefined ? 32 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */;
+    const parentType = getTypeForBindingElementParent(c, pattern.parent, checkMode);
+    if (parentType === undefined || parentType === c.errorType)
+        return parentType;
+    return getBindingElementTypeFromParentType(c, declaration, parentType, false);
+}
+/** The type of a destructured element narrowed like `init["name"]` at the position of its initializer. */
+function getFlowTypeOfDestructuring(c, node, declaredType) {
+    const reference = getSyntheticElementAccess(c, node);
+    return reference !== undefined
+        ? getFlowTypeOfReference(c, reference, declaredType, declaredType, undefined)
+        : declaredType;
+}
+function getSyntheticElementAccess(c, node) {
+    const parentAccess = getParentElementAccess(c, node);
+    if (parentAccess === undefined)
+        return undefined;
+    const flowNode = getFlowNode(parentAccess);
+    if (flowNode === undefined)
+        return undefined;
+    const propName = getDestructuringPropertyName(c, node);
+    if (propName === undefined)
+        return undefined;
+    const literal = new StringLiteral(propName, 0 /* TokenFlags.None */);
+    literal.pos = node.pos;
+    literal.end = node.end;
+    let lhs = parentAccess;
+    if (!isLeftHandSideExpression(parentAccess)) {
+        lhs = new ParenthesizedExpression(parentAccess);
+        lhs.pos = node.pos;
+        lhs.end = node.end;
+    }
+    const result = new ElementAccessExpression(lhs, undefined, literal, 0 /* NodeFlags.None */);
+    result.pos = node.pos;
+    result.end = node.end;
+    literal.parent = result;
+    result.parent = node;
+    if (lhs !== parentAccess)
+        lhs.parent = result;
+    result.flowNode = flowNode;
+    return result;
+}
+function getParentElementAccess(c, node) {
+    const ancestor = node.parent.parent;
+    switch (ancestor.kind) {
+        case 209 /* SyntaxKind.BindingElement */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return getSyntheticElementAccess(c, ancestor);
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return getSyntheticElementAccess(c, node.parent);
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            return getInitializer(ancestor);
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return ancestor.right;
+    }
+    return undefined;
+}
+export function getTypeForBindingElementParent(c, node, checkMode) {
+    if (checkMode === 0 /* CheckMode.Normal */) {
+        // A resolved type can be used when it includes no optionality.
+        const symbol = getSymbolOfDeclaration(c, node);
+        if (symbol !== undefined) {
+            const cached = c.symbolTypes.get(getSymbolId(symbol));
+            if (cached !== undefined && !(c.strictNullChecks && isOptionalDeclaration(node)))
+                return cached;
+        }
+    }
+    return getTypeForVariableLikeDeclaration(c, node, false, checkMode);
+}
+export function getBindingElementTypeFromParentType(c, declaration, parentTypeIn, noTupleBoundsCheck) {
+    if ((parentTypeIn.flags & 1 /* TypeFlags.Any */) !== 0)
+        return parentTypeIn;
+    let parentType = parentTypeIn;
+    const pattern = declaration.parent;
+    const parentInitializer = getInitializer(pattern.parent);
+    // Ambient destructuring parameters are documentation only, so nullability isn't checked.
+    if (c.strictNullChecks && (declaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && isPartOfParameterDeclaration(declaration))
+        parentType = getNonNullableType(c, parentType);
+    else if (c.strictNullChecks &&
+        parentInitializer !== undefined &&
+        !hasTypeFacts(c, getTypeOfInitializer(c, parentInitializer), 65536 /* TypeFacts.EQUndefined */))
+        parentType = getTypeWithFacts(c, parentType, 524288 /* TypeFacts.NEUndefined */);
+    const accessFlags = 32 /* AccessFlags.ExpressionPosition */ |
+        (noTupleBoundsCheck || declaration.initializer !== undefined ? 16 /* AccessFlags.AllowMissing */ : 0);
+    let t;
+    if (pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */) {
+        if (declaration.dotDotDotToken !== undefined) {
+            parentType = getReducedType(c, parentType);
+            if ((parentType.flags & 2 /* TypeFlags.Unknown */) !== 0 || !isValidSpreadType(c, parentType)) {
+                c.error(declaration, 832 /* Diagnostics.Rest_types_may_only_be_created_from_object_types */);
+                return c.errorType;
+            }
+            const literalMembers = [];
+            for (const e of getElements(pattern).nodes) {
+                const element = e;
+                if (element.dotDotDotToken === undefined)
+                    literalMembers.push(element.propertyName ?? element.name);
+            }
+            t = getRestType(c, parentType, literalMembers, getSymbol(declaration));
+        }
+        else {
+            const name = declaration.propertyName ?? declaration.name;
+            const declaredType = getIndexedAccessTypeEx(c, parentType, getLiteralTypeFromPropertyName(c, name) ?? c.errorType, accessFlags, name, undefined);
+            t = getFlowTypeOfDestructuring(c, declaration, declaredType);
+        }
+    }
+    else {
+        // Used when the tuple element for the index is missing; also checks that the parent is iterable.
+        const elementType = checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */ | (declaration.dotDotDotToken !== undefined ? 0 : 128 /* IterationUse.PossiblyOutOfBounds */), parentType, c.undefinedType, pattern);
+        const index = getElements(pattern).nodes.indexOf(declaration);
+        if (declaration.dotDotDotToken !== undefined) {
+            // A rest element of a tuple gets the remaining elements; of an array, the same array type.
+            const baseConstraint = mapType(c, parentType, (u) => (u.flags & 117964800 /* TypeFlags.InstantiableNonPrimitive */) !== 0 ? getBaseConstraintOrType(c, u) : u);
+            t = everyType(baseConstraint, isTupleType)
+                ? mapType(c, baseConstraint, (u) => sliceTupleType(c, u, index, 0))
+                : createArrayType(c, elementType);
+        }
+        else if (isArrayLikeType(c, parentType)) {
+            const declaredType = getIndexedAccessTypeOrUndefinedEx(c, parentType, getNumberLiteralType(c, index), accessFlags, declaration.name, undefined) ?? c.errorType;
+            t = getFlowTypeOfDestructuring(c, declaration, declaredType);
+        }
+        else
+            t = elementType;
+    }
+    if (declaration.initializer === undefined)
+        return t;
+    if (getType(walkUpBindingElementsAndPatterns(declaration)) !== undefined) {
+        // A default without undefined removes undefined from an annotated type.
+        if (c.strictNullChecks && !hasTypeFacts(c, checkDeclarationInitializer(c, declaration), 16777216 /* TypeFacts.IsUndefined */))
+            return getNonUndefinedType(c, t);
+        return t;
+    }
+    return widenTypeInferredFromInitializer(c, declaration, getUnionTypeEx(c, [getNonUndefinedType(c, t), checkDeclarationInitializer(c, declaration)], 2 /* UnionReduction.Subtype */, undefined, undefined));
+}
+/** The binding pattern's root declaration: the variable or parameter it destructures. */
+function walkUpBindingElementsAndPatterns(node) {
+    let current = node.parent;
+    while (current.kind === 209 /* SyntaxKind.BindingElement */ || isBindingPatternNode(current))
+        current = current.parent;
+    return current;
+}
+/** `t` without undefined, also when it's a generic type whose constraint includes undefined. */
+export function getNonUndefinedType(c, t) {
+    const typeOrConstraint = someType(t, (u) => isGenericTypeWithUndefinedConstraint(c, u))
+        ? mapType(c, t, (u) => ((u.flags & 132644864 /* TypeFlags.Instantiable */) !== 0 ? getBaseConstraintOrType(c, u) : u))
+        : t;
+    return getTypeWithFacts(c, typeOrConstraint, 524288 /* TypeFacts.NEUndefined */);
+}
+function isGenericTypeWithUndefinedConstraint(c, t) {
+    if ((t.flags & 132644864 /* TypeFlags.Instantiable */) === 0)
+        return false;
+    const constraint = getBaseConstraintOfType(c, t);
+    return constraint !== undefined && maybeTypeOfKind(constraint, 4 /* TypeFlags.Undefined */);
+}
+/** The type implied by a binding pattern, for declarations without annotations or initializers. */
+export function getTypeFromBindingPattern(c, pattern, includePatternInType, reportErrors) {
+    // References to the pattern's own elements in its initializers are `any` while its type is a contextual type.
+    if (includePatternInType)
+        c.contextualBindingPatterns.push(pattern);
+    const result = pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */
+        ? getTypeFromObjectBindingPattern(c, pattern, includePatternInType, reportErrors)
+        : getTypeFromArrayBindingPattern(c, pattern, includePatternInType, reportErrors);
+    if (includePatternInType)
+        c.contextualBindingPatterns.pop();
+    return result;
+}
+function getTypeFromObjectBindingPattern(c, pattern, includePatternInType, reportErrors) {
+    const members = new Map();
+    const indexInfos = [];
+    let objectFlags = 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    for (const node of getElements(pattern).nodes) {
+        const e = node;
+        if (e.dotDotDotToken !== undefined) {
+            indexInfos.push(newIndexInfo(c.stringType, c.anyType, false, undefined));
+            continue;
+        }
+        const exprType = getLiteralTypeFromPropertyName(c, e.propertyName ?? e.name) ?? c.errorType;
+        if (!isTypeUsableAsPropertyName(exprType)) {
+            objectFlags |= 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */;
+            continue;
+        }
+        const flags = 4 /* SymbolFlags.Property */ | (e.initializer !== undefined ? 16777216 /* SymbolFlags.Optional */ : 0);
+        const symbol = c.newSymbol(flags, getPropertyNameFromType(exprType));
+        c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, includePatternInType, reportErrors));
+        members.set(symbol.name, symbol);
+    }
+    const result = createAnonymousType(c, undefined, members, [], [], indexInfos);
+    result.objectFlags |= objectFlags;
+    if (includePatternInType) {
+        c.patternForType.set(result, pattern);
+        result.objectFlags |= 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    }
+    return result;
+}
+function getTypeFromArrayBindingPattern(c, pattern, includePatternInType, reportErrors) {
+    const elements = getElements(pattern).nodes;
+    const last = elements.length > 0 ? elements[elements.length - 1] : undefined;
+    const restElement = last !== undefined &&
+        last.kind === 209 /* SyntaxKind.BindingElement */ &&
+        last.dotDotDotToken !== undefined
+        ? last
+        : undefined;
+    if (elements.length === 0 || (elements.length === 1 && restElement !== undefined))
+        return c.languageVersion >= ScriptTarget.ES2015 ? createIterableType(c, c.anyType) : c.anyArrayType;
+    let minLength = 0;
+    for (let i = elements.length - 1; i >= 0; i--) {
+        const e = elements[i];
+        if (!(e === restElement || getName(e) === undefined || getInitializer(e) !== undefined)) {
+            minLength = i + 1;
+            break;
+        }
+    }
+    const types = [];
+    const infos = [];
+    for (let i = 0; i < elements.length; i++) {
+        const e = elements[i];
+        types.push(
+        // Omitted elements are binding elements without a name.
+        getName(e) === undefined
+            ? c.anyType
+            : getTypeFromBindingElement(c, e, includePatternInType, reportErrors));
+        const flags = e === restElement ? 4 /* ElementFlags.Rest */ : i >= minLength ? 2 /* ElementFlags.Optional */ : 1 /* ElementFlags.Required */;
+        infos.push(new TupleElementInfo(flags, undefined));
+    }
+    const result = createTupleTypeEx(c, types, infos, false);
+    if (!includePatternInType)
+        return result;
+    const clone = cloneTypeReference(c, result);
+    c.patternForType.set(clone, pattern);
+    clone.objectFlags |= 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    return clone;
+}
+function getTypeFromBindingElement(c, element, includePatternInType, reportErrors) {
+    if (element.initializer !== undefined) {
+        // The implied type doesn't depend on context: the initializer is checked without a contextual
+        // type, or with the type implied by the element's own pattern.
+        const contextualType = isBindingPatternNode(element.name)
+            ? getTypeFromBindingPattern(c, element.name, true, false)
+            : c.unknownType;
+        const t = checkDeclarationInitializer(c, element, 0 /* CheckMode.Normal */, contextualType);
+        return addOptionality(c, getWidenedLiteralTypeForInitializer(c, element, t), false, true);
+    }
+    if (isBindingPatternNode(element.name))
+        return getTypeFromBindingPattern(c, element.name, includePatternInType, reportErrors);
+    if (reportErrors && c.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element))
+        reportImplicitAny(c, element, c.anyType);
+    return includePatternInType ? c.nonInferrableAnyType : c.anyType;
+}
+/**
+ * The initializer type of a parameter or its binding element, padded with the members its binding
+ * pattern defaults or binds past the end of a tuple.
+ */
+export function padParameterInitializerType(c, declaration, t) {
+    if (getRootDeclaration(declaration).kind !== 170 /* SyntaxKind.Parameter */)
+        return t;
+    const name = getName(declaration);
+    if (name === undefined)
+        return t;
+    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ && (t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0)
+        return padObjectLiteralType(c, t, name);
+    if (name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ && isTupleType(t))
+        return padTupleType(c, t, name);
+    return t;
+}
+/** An object literal type with optional properties added for the pattern's defaulted elements it lacks. */
+function padObjectLiteralType(c, t, pattern) {
+    const missingElements = [];
+    for (const node of getElements(pattern).nodes) {
+        const e = node;
+        if (e.initializer === undefined)
+            continue;
+        const name = getPropertyNameFromBindingElement(c, e);
+        if (name !== undefined && getPropertyOfType(c, t, name) === undefined)
+            missingElements.push(e);
+    }
+    if (missingElements.length === 0)
+        return t;
+    const members = new Map();
+    for (const prop of getPropertiesOfObjectType(c, t))
+        members.set(prop.name, prop);
+    for (const e of missingElements) {
+        const symbol = c.newSymbol(4 /* SymbolFlags.Property */ | 16777216 /* SymbolFlags.Optional */, getPropertyNameFromBindingElement(c, e));
+        c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, false, false));
+        members.set(symbol.name, symbol);
+    }
+    const result = createAnonymousType(c, t.symbol, members, [], [], getIndexInfosOfType(c, t));
+    result.objectFlags = (t.objectFlags & ~-2147483648 /* ObjectFlags.SideState */) | (result.objectFlags & -2147483648 /* ObjectFlags.SideState */);
+    return result;
+}
+function getPropertyNameFromBindingElement(c, e) {
+    const exprType = getLiteralTypeFromPropertyName(c, e.propertyName ?? e.name);
+    return exprType !== undefined && isTypeUsableAsPropertyName(exprType) ? getPropertyNameFromType(exprType) : undefined;
+}
+/**
+ * A parameter's tuple initializer type, padded with optional elements for the pattern's elements
+ * past its end, so `([x, y] = [1])` gets `[number, any?]`.
+ */
+export function padTupleType(c, t, pattern) {
+    const patternElements = getElements(pattern).nodes;
+    const target = tupleTargetOf(t);
+    const arity = getTypeReferenceArity(t);
+    if ((target.combinedFlags & 12 /* ElementFlags.Variable */) !== 0 || arity >= patternElements.length)
+        return t;
+    const elementTypes = getElementTypes(c, t).slice();
+    const elementInfos = target.elementInfos.slice();
+    for (let i = arity; i < patternElements.length; i++) {
+        const e = patternElements[i];
+        if (i < patternElements.length - 1 ||
+            !(e.kind === 209 /* SyntaxKind.BindingElement */ && e.dotDotDotToken !== undefined)) {
+            const omitted = e.kind === 233 /* SyntaxKind.OmittedExpression */;
+            elementTypes.push(!omitted && hasDefaultValue(e) ? getTypeFromBindingElement(c, e, false, false) : c.anyType);
+            elementInfos.push(new TupleElementInfo(2 /* ElementFlags.Optional */, undefined));
+            if (!omitted && !hasDefaultValue(e))
+                reportImplicitAny(c, e, c.anyType);
+        }
+    }
+    return createTupleTypeEx(c, elementTypes, elementInfos, target.readonly);
+}
+// ---- Destructuring assignments
+/** Checks an assignment of `sourceType` to a target, which may be an object or array literal pattern. */
+export function checkDestructuringAssignment(c, node, sourceTypeIn, checkMode, rightIsThis) {
+    let sourceType = sourceTypeIn;
+    let target = node;
+    if (node.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */) {
+        const shorthand = node;
+        const initializer = shorthand.objectAssignmentInitializer;
+        if (initializer !== undefined) {
+            // A default of a type without undefined removes undefined from the assigned type.
+            if (c.strictNullChecks && !hasTypeFacts(c, checkExpression(c, initializer), 16777216 /* TypeFacts.IsUndefined */))
+                sourceType = getTypeWithFacts(c, sourceType, 524288 /* TypeFacts.NEUndefined */);
+            checkShorthandDefault(c, shorthand, initializer, checkMode);
+        }
+        target = shorthand.name;
+    }
+    if (target.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        target.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) {
+        checkBinaryExpression(c, target, checkMode);
+        target = target.left;
+        if (c.strictNullChecks)
+            sourceType = getTypeWithFacts(c, sourceType, 524288 /* TypeFacts.NEUndefined */);
+    }
+    if (target.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+        return checkObjectLiteralAssignment(c, target, sourceType, rightIsThis);
+    if (target.kind === 210 /* SyntaxKind.ArrayLiteralExpression */)
+        return checkArrayLiteralAssignment(c, target, sourceType, checkMode);
+    return checkReferenceAssignment(c, target, sourceType, checkMode);
+}
+/** Checks `name = initializer` in a shorthand property of an assignment pattern. */
+function checkShorthandDefault(c, node, initializer, checkMode) {
+    const leftType = checkExpressionCached(c, node.name);
+    const rightType = checkExpressionEx(c, initializer, checkMode);
+    if (checkReferenceExpression(c, node.name, 538 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, 911 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
+        checkTypeAssignableToAndOptionallyElaborate(c, rightType, leftType, node.name, initializer);
+}
+function checkObjectLiteralAssignment(c, node, sourceType, rightIsThis) {
+    const properties = getProperties(node).nodes;
+    if (c.strictNullChecks && properties.length === 0)
+        return checkNonNullType(c, sourceType, node);
+    for (let i = 0; i < properties.length; i++)
+        checkObjectLiteralDestructuringPropertyAssignment(c, properties, sourceType, i, rightIsThis);
+    return sourceType;
+}
+function checkObjectLiteralDestructuringPropertyAssignment(c, properties, objectLiteralType, propertyIndex, rightIsThis) {
+    const property = properties[propertyIndex];
+    if (property.kind === 303 /* SyntaxKind.PropertyAssignment */ || property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */) {
+        const name = getName(property);
+        markDestructuredPropertyAsReferenced(c, objectLiteralType, name, property, rightIsThis);
+        const exprType = getLiteralTypeFromPropertyName(c, name) ?? c.errorType;
+        if (isTypeUsableAsPropertyName(exprType)) {
+            const prop = getPropertyOfType(c, objectLiteralType, getPropertyNameFromType(exprType));
+            if (prop !== undefined)
+                checkPropertyAccessibility(c, property, false, true, objectLiteralType, prop);
+        }
+        const elementType = getIndexedAccessTypeEx(c, objectLiteralType, exprType, 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(property) ? 16 /* AccessFlags.AllowMissing */ : 0), name, undefined);
+        const expr = property.kind === 303 /* SyntaxKind.PropertyAssignment */ ? property.initializer : property;
+        checkDestructuringAssignment(c, expr, getFlowTypeOfDestructuring(c, property, elementType), 0 /* CheckMode.Normal */, false);
+        return;
+    }
+    if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+        if (propertyIndex < properties.length - 1) {
+            c.error(property, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+            return;
+        }
+        if (c.languageVersion < ScriptTarget.ES2018)
+            checkExternalEmitHelpers(c, property, 1 /* ExternalEmitHelpers.Rest */);
+        const nonRestNames = [];
+        for (const other of properties)
+            if (other.kind !== 305 /* SyntaxKind.SpreadAssignment */)
+                nonRestNames.push(getName(other));
+        const t = getRestType(c, objectLiteralType, nonRestNames, objectLiteralType.symbol);
+        checkGrammarRestTrailingComma(c, property.parent, getProperties(property.parent));
+        checkDestructuringAssignment(c, property.expression, t, 0 /* CheckMode.Normal */, false);
+        return;
+    }
+    c.error(property, 102 /* Diagnostics.Property_assignment_expected */);
+}
+function checkArrayLiteralAssignment(c, node, sourceType, checkMode) {
+    const elements = getElements(node).nodes;
+    // Used when the tuple element for an index is missing; also checks that the source is iterable.
+    const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */ | 128 /* IterationUse.PossiblyOutOfBounds */, sourceType, c.undefinedType, node);
+    let inBoundsType = c.noUncheckedIndexedAccess ? undefined : possiblyOutOfBoundsType;
+    for (let i = 0; i < elements.length; i++) {
+        let t = possiblyOutOfBoundsType;
+        if (elements[i].kind === 231 /* SyntaxKind.SpreadElement */) {
+            if (inBoundsType === undefined)
+                inBoundsType = checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, sourceType, c.undefinedType, node);
+            t = inBoundsType;
+        }
+        checkArrayLiteralDestructuringElementAssignment(c, elements, sourceType, i, t, checkMode);
+    }
+    return sourceType;
+}
+function checkArrayLiteralDestructuringElementAssignment(c, elements, sourceType, elementIndex, elementType, checkMode) {
+    const element = elements[elementIndex];
+    if (element.kind === 233 /* SyntaxKind.OmittedExpression */)
+        return;
+    if (element.kind !== 231 /* SyntaxKind.SpreadElement */) {
+        if (isArrayLikeType(c, sourceType)) {
+            const indexType = getNumberLiteralType(c, elementIndex);
+            const accessFlags = 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* AccessFlags.AllowMissing */ : 0);
+            // Element access targets would be mistaken for the access itself.
+            const accessNode = element.kind === 213 /* SyntaxKind.ElementAccessExpression */ ? undefined : element;
+            const t = getIndexedAccessTypeOrUndefinedEx(c, sourceType, indexType, accessFlags, accessNode, undefined) ?? c.errorType;
+            const assigned = hasDefaultValue(element) ? getTypeWithFacts(c, t, 524288 /* TypeFacts.NEUndefined */) : t;
+            checkDestructuringAssignment(c, element, getFlowTypeOfDestructuring(c, element, assigned), checkMode, false);
+            return;
+        }
+        checkDestructuringAssignment(c, element, elementType, checkMode, false);
+        return;
+    }
+    if (elementIndex < elements.length - 1) {
+        c.error(element, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+        return;
+    }
+    const restExpression = element.expression;
+    if (restExpression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        restExpression.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) {
+        c.error(restExpression.operatorToken, 142 /* Diagnostics.A_rest_element_cannot_have_an_initializer */);
+        return;
+    }
+    checkGrammarRestTrailingComma(c, element, getElements(element.parent));
+    const t = everyType(sourceType, isTupleType)
+        ? mapType(c, sourceType, (u) => sliceTupleType(c, u, elementIndex, 0))
+        : createArrayType(c, elementType);
+    checkDestructuringAssignment(c, restExpression, t, checkMode, false);
+}
+function checkReferenceAssignment(c, target, sourceType, checkMode) {
+    const targetType = checkExpressionEx(c, target, checkMode);
+    const inRest = target.parent.kind === 305 /* SyntaxKind.SpreadAssignment */;
+    if (checkReferenceExpression(c, target, inRest
+        ? 833 /* Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access */
+        : 538 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, inRest
+        ? 910 /* Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access */
+        : 911 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
+        checkTypeAssignableToAndOptionallyElaborate(c, sourceType, targetType, target, target);
+    return sourceType;
+}
+/** Whether a destructuring element has a default value. */
+export function hasDefaultValue(node) {
+    switch (node.kind) {
+        case 209 /* SyntaxKind.BindingElement */:
+            return node.initializer !== undefined;
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return hasDefaultValue(node.initializer);
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return node.objectAssignmentInitializer !== undefined;
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */;
+    }
+    return false;
+}
+// ---- Rest types
+/** The type of an object rest element: `source` without the named properties. */
+export function getRestType(c, sourceIn, properties, symbol) {
+    const source = filterType(c, sourceIn, (t) => (t.flags & 12 /* TypeFlags.Nullable */) === 0);
+    if ((source.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return c.emptyObjectType;
+    if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return mapType(c, source, (t) => getRestType(c, t, properties, symbol));
+    const omitKeys = [];
+    for (const p of properties)
+        omitKeys.push(getLiteralTypeFromPropertyName(c, p) ?? c.errorType);
+    let omitKeyType = getUnionType(c, omitKeys);
+    const spreadable = [];
+    const unspreadableKeys = [];
+    for (const prop of getPropertiesOfType(c, source)) {
+        const literal = getLiteralTypeFromProperty(c, prop, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */, false);
+        if (!isTypeAssignableTo(c, literal, omitKeyType) &&
+            (getDeclarationModifierFlagsFromSymbol(c, prop, false) & (2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */)) ===
+                0 &&
+            isSpreadableProperty(prop))
+            spreadable.push(prop);
+        else
+            unspreadableKeys.push(literal);
+    }
+    if (isGenericObjectType(c, source) || isGenericIndexType(c, omitKeyType)) {
+        // Members a rest element never receives, like methods, are omitted explicitly as well.
+        if (unspreadableKeys.length !== 0)
+            omitKeyType = getUnionType(c, [omitKeyType, ...unspreadableKeys]);
+        if ((omitKeyType.flags & 262144 /* TypeFlags.Never */) !== 0)
+            return source;
+        const omit = getGlobalTypeAliasSymbol(c, 'Omit', 2, true);
+        if (omit === undefined)
+            return c.errorType;
+        return getTypeAliasInstantiation(c, omit, [source, omitKeyType], undefined);
+    }
+    const members = new Map();
+    for (const prop of spreadable)
+        members.set(prop.name, getSpreadSymbol(c, prop, false));
+    const result = createAnonymousType(c, symbol, members, [], [], getIndexInfosOfType(c, source));
+    result.objectFlags |= 8388608 /* ObjectFlags.ObjectRestType */;
+    return result;
+}
+/** Approximates own properties: non-methods, plus methods declared outside classes. */
+export function isSpreadableProperty(prop) {
+    const notMethodOrAccessor = (prop.flags & (8192 /* SymbolFlags.Method */ | 32768 /* SymbolFlags.GetAccessor */ | 65536 /* SymbolFlags.SetAccessor */)) === 0;
+    let hasPrivateName = false;
+    let inClass = false;
+    for (const d of prop.declarations) {
+        if (isPrivateIdentifierClassElementDeclaration(d))
+            hasPrivateName = true;
+        if (d.parent !== undefined && isClassLike(d.parent))
+            inClass = true;
+    }
+    return (!hasPrivateName && notMethodOrAccessor) || !inClass;
+}
+/** `prop` as a member of a spread or rest type, with the given readonlyness. */
+export function getSpreadSymbol(c, prop, readonly) {
+    const isSetonlyAccessor = (prop.flags & 65536 /* SymbolFlags.SetAccessor */) !== 0 && (prop.flags & 32768 /* SymbolFlags.GetAccessor */) === 0;
+    if (!isSetonlyAccessor && readonly === isReadonlySymbol(c, prop))
+        return prop;
+    const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & 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 : getTypeOfSymbol(c, prop));
+    result.declarations = prop.declarations;
+    c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
+    c.symbolSyntheticOrigins.set(id, prop);
+    return result;
+}
+/** Whether a type may be spread into an object or destructured by an object rest element. */
+export function isValidSpreadType(c, t) {
+    const s = removeDefinitelyFalsyTypes(c, mapToBaseConstraintOrType(c, t));
+    if ((s.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.NonPrimitive */ | 1048576 /* TypeFlags.Object */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) !==
+        0)
+        return true;
+    if ((s.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0)
+        return false;
+    for (const u of typesOf(s))
+        if (!isValidSpreadType(c, u))
+            return false;
+    return true;
+}

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

@@ -0,0 +1,15 @@
+import { type Node } from './ast.js';
+import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+import { type Relation } from './relations.js';
+/** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
+export declare function checkTypeRelatedToAndOptionallyElaborate(c: Checker, source: Type, target: Type, relation: Relation, errorNode: Node | undefined, expr: Node | undefined, headMessage: DiagnosticMessage | undefined, diagnosticOutput: Diagnostic[] | undefined): boolean;
+export declare function elaborateError(c: Checker, node: Node | undefined, source: Type, target: Type, relation: Relation, headMessage: DiagnosticMessage | undefined, diagnosticOutput: Diagnostic[] | undefined): boolean;
+/**
+ * Elaborates the element `nameType` of `source` against `target`, reporting at `prop`. With `customMessage`,
+ * that message is reported instead of the relation error.
+ */
+export declare function elaborateElement(c: Checker, source: Type, target: Type, relation: Relation, prop: Node, next: Node | undefined, nameType: Type, errorMessage: DiagnosticMessage | undefined, customMessage: DiagnosticMessage | undefined, customArgs: string[], diagnosticOutput: Diagnostic[] | undefined): boolean;
+export declare function getBestMatchIndexedAccessTypeOrUndefined(c: Checker, source: Type, target: Type, nameType: Type): Type | undefined;
+export declare function checkExpressionForMutableLocationWithContextualType(c: Checker, next: Node, sourcePropType: Type): Type;