Commit e434155

const parentType = getTypeForBindingElementParent(declaration.parent.parent);

return parentType && getBindingElementTypeFromParentType(declaration, parentType);

}

function getBindingElementTypeFromParentType(declaration: BindingElement, parentType: Type): Type {

// If an any type was inferred for parent, infer that for the binding element

if (isTypeAny(parentType)) {

const pattern = declaration.parent;

function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = reference.flowNode) {

if (!flowNode) {

const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));

function getCandidateDiscriminantPropertyAccess(expr: Expression) {

if (isBindingPattern(reference)) {

// When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.

// An identifier for a destructuring variable declared in the same binding pattern is a candidate.

if (isIdentifier(expr)) {

const symbol = getResolvedSymbol(expr);

const declaration = symbol.valueDeclaration;

if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {

return declaration;

}

}

}

else if (isAccessExpression(expr)) {

// An access expression is a candidate if the reference matches the left hand expression.

if (isMatchingReference(reference, expr.expression)) {

return expr;

}

}

else if (isIdentifier(expr)) {

const symbol = getResolvedSymbol(expr);

if (isConstVariable(symbol)) {

const declaration = symbol.valueDeclaration!;

// Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'

if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) &&

isMatchingReference(reference, declaration.initializer.expression)) {

return declaration.initializer;

}

// Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'

if (isBindingElement(declaration) && !declaration.initializer) {

const parent = declaration.parent.parent;

if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) &&

isMatchingReference(reference, parent.initializer)) {

return declaration;

}

}

}

}

return undefined;

}

if (type.flags & TypeFlags.Union) {

const access = getCandidateDiscriminantPropertyAccess(expr);

if (access) {

const name = getAccessedPropertyName(access);

if (name && isDiscriminantProperty(type, name)) {

return access;

}

}

}

return undefined;

function getNarrowedTypeOfSymbol(symbol: Symbol, location: Identifier) {

// If we have a non-rest binding element with no initializer declared as a const variable or a const-like

// parameter (a parameter for which there are no assignments in the function body), and if the parent type

// for the destructuring is a union type, one or more of the binding elements may represent discriminant

// properties, and we want the effects of conditional checks on such discriminants to affect the types of

// other binding elements from the same destructuring. Consider:

//

// type Action =

// | { kind: 'A', payload: number }

// | { kind: 'B', payload: string };

//

// function f1({ kind, payload }: Action) {

// if (kind === 'A') {

// payload.toFixed();

// }

// if (kind === 'B') {

// payload.toUpperCase();

// }

// }

//

// Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use

// the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference

// as if it occurred in the specified location. We then recompute the narrowed binding element type by

// destructuring from the narrowed parent type.

const declaration = symbol.valueDeclaration;

if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {

const parent = declaration.parent.parent;

if (parent.kind === SyntaxKind.VariableDeclaration && getCombinedNodeFlags(declaration) & NodeFlags.Const || parent.kind === SyntaxKind.Parameter) {

const links = getNodeLinks(location);

if (!(links.flags & NodeCheckFlags.InCheckIdentifier)) {

links.flags |= NodeCheckFlags.InCheckIdentifier;

const parentType = getTypeForBindingElementParent(parent);

links.flags &= ~NodeCheckFlags.InCheckIdentifier;

if (parentType && parentType.flags & TypeFlags.Union && !(parent.kind === SyntaxKind.Parameter && isSymbolAssigned(symbol))) {

const pattern = declaration.parent;

const narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);

return getBindingElementTypeFromParentType(declaration, narrowedType);

}

}

}

}

return getTypeOfSymbol(symbol);

}

let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);