if (isBindingPattern(declaration.parent)) {

const parentDeclaration = declaration.parent.parent;

const name = declaration.propertyName || declaration.name;

parentDeclaration.type &&

!isBindingPattern(name)) {

const text = getTextOfPropertyName(name);

export interface TypeParameterDeclaration extends Declaration {

kind: SyntaxKind.TypeParameter;

name: Identifier;

constraint?: TypeNode;

default?: TypeNode;

export interface VariableDeclaration extends Declaration {

kind: SyntaxKind.VariableDeclaration;

name: BindingName; // Declared variable name

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface VariableDeclarationList extends Node {

kind: SyntaxKind.VariableDeclarationList;

declarations: NodeArray<VariableDeclaration>;

}

export interface ParameterDeclaration extends Declaration {

kind: SyntaxKind.Parameter;

dotDotDotToken?: DotDotDotToken; // Present on rest parameter

name: BindingName; // Declared parameter name

questionToken?: QuestionToken; // Present on optional parameter

export interface BindingElement extends Declaration {

kind: SyntaxKind.BindingElement;

propertyName?: PropertyName; // Binding property name (in object binding pattern)

dotDotDotToken?: DotDotDotToken; // Present on rest element (in object binding pattern)

name: BindingName; // Declared binding element name

export interface ObjectBindingPattern extends Node {

kind: SyntaxKind.ObjectBindingPattern;

elements: NodeArray<BindingElement>;

}

export interface ArrayBindingPattern extends Node {

kind: SyntaxKind.ArrayBindingPattern;

elements: NodeArray<ArrayBindingElement>;

}

export interface TemplateHead extends LiteralLikeNode {

kind: SyntaxKind.TemplateHead;

}

export interface TemplateMiddle extends LiteralLikeNode {

kind: SyntaxKind.TemplateMiddle;

}

export interface TemplateTail extends LiteralLikeNode {

kind: SyntaxKind.TemplateTail;

}

export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;

// The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral.

export interface TemplateSpan extends Node {

kind: SyntaxKind.TemplateSpan;

expression: Expression;

literal: TemplateMiddle | TemplateTail;

}

export interface ExpressionWithTypeArguments extends TypeNode {

kind: SyntaxKind.ExpressionWithTypeArguments;

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

}

/// The opening element of a <Tag>...</Tag> JsxElement

export interface JsxOpeningElement extends Expression {

kind: SyntaxKind.JsxOpeningElement;

tagName: JsxTagNameExpression;

attributes: JsxAttributes;

}

export interface JsxAttribute extends ObjectLiteralElement {

kind: SyntaxKind.JsxAttribute;

name: Identifier;

/// JSX attribute initializers are optional; <X y /> is sugar for <X y={true} />

initializer?: StringLiteral | JsxExpression;

}

export interface JsxSpreadAttribute extends ObjectLiteralElement {

kind: SyntaxKind.JsxSpreadAttribute;

expression: Expression;

}

export interface JsxClosingElement extends Node {

kind: SyntaxKind.JsxClosingElement;

tagName: JsxTagNameExpression;

}

export interface JsxExpression extends Expression {

kind: SyntaxKind.JsxExpression;

dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;

expression?: Expression;

}

export interface JsxText extends Node {

kind: SyntaxKind.JsxText;

}

export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement;

export interface CaseBlock extends Node {

kind: SyntaxKind.CaseBlock;

clauses: NodeArray<CaseOrDefaultClause>;

}

export interface CaseClause extends Node {

kind: SyntaxKind.CaseClause;

expression: Expression;

statements: NodeArray<Statement>;

}

export interface DefaultClause extends Node {

kind: SyntaxKind.DefaultClause;

statements: NodeArray<Statement>;

}

export interface CatchClause extends Node {

kind: SyntaxKind.CatchClause;

variableDeclaration: VariableDeclaration;

block: Block;

}

export interface HeritageClause extends Node {

kind: SyntaxKind.HeritageClause;

token: SyntaxKind;

types?: NodeArray<ExpressionWithTypeArguments>;

}

export interface EnumMember extends Declaration {

kind: SyntaxKind.EnumMember;

// This does include ComputedPropertyName, but the parser will give an error

// if it parses a ComputedPropertyName in an EnumMember

name: PropertyName;

export interface ModuleDeclaration extends DeclarationStatement {

kind: SyntaxKind.ModuleDeclaration;

body?: ModuleBody | JSDocNamespaceDeclaration | Identifier;

}

export interface ModuleBlock extends Node, Statement {

kind: SyntaxKind.ModuleBlock;

statements: NodeArray<Statement>;

}

export type ModuleReference = EntityName | ExternalModuleReference;

export interface ImportEqualsDeclaration extends DeclarationStatement {

kind: SyntaxKind.ImportEqualsDeclaration;

name: Identifier;

// 'EntityName' for an internal module reference, 'ExternalModuleReference' for an external

export interface ExternalModuleReference extends Node {

kind: SyntaxKind.ExternalModuleReference;

expression?: Expression;

}

// ImportClause information is shown at its declaration below.

export interface ImportDeclaration extends Statement {

kind: SyntaxKind.ImportDeclaration;

importClause?: ImportClause;

moduleSpecifier: Expression;

}

// import d, { a, b as x } from "mod" => name = d, namedBinding: NamedImports = { elements: [{ name: a }, { name: x, propertyName: b}]}

export interface ImportClause extends Declaration {

kind: SyntaxKind.ImportClause;

name?: Identifier; // Default binding

namedBindings?: NamedImportBindings;

}

export interface NamespaceImport extends Declaration {

kind: SyntaxKind.NamespaceImport;

name: Identifier;

}

export interface ExportDeclaration extends DeclarationStatement {

kind: SyntaxKind.ExportDeclaration;

exportClause?: NamedExports;

moduleSpecifier?: Expression;

}

export interface NamedImports extends Node {

kind: SyntaxKind.NamedImports;

elements: NodeArray<ImportSpecifier>;

}

export interface NamedExports extends Node {

kind: SyntaxKind.NamedExports;

elements: NodeArray<ExportSpecifier>;

}

export type NamedImportsOrExports = NamedImports | NamedExports;

export interface ImportSpecifier extends Declaration {

kind: SyntaxKind.ImportSpecifier;

propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent)

name: Identifier; // Declared name

}

export interface ExportSpecifier extends Declaration {

kind: SyntaxKind.ExportSpecifier;

propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent)

name: Identifier; // Declared name

}

export interface ExportAssignment extends DeclarationStatement {

kind: SyntaxKind.ExportAssignment;

isExportEquals?: boolean;

expression: Expression;

}

}

function textSpanFromVariableDeclaration(variableDeclaration: VariableDeclaration): TextSpan {

// First declaration - include let keyword

return textSpan(findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration);

}

return textSpanFromVariableDeclaration(variableDeclaration);

}

// If we cannot set breakpoint on this declaration, set it on previous one

// Because the variable declaration may be binding pattern and

// we would like to set breakpoint in last binding element if that's the case,