/// <reference path="..\compiler\program.ts"/>

/// <reference path='breakpoints.ts' />

/// <reference path='outliningElementsCollector.ts' />

/// <reference path='navigateTo.ts' />

/// <reference path='navigationBar.ts' />

/// <reference path='patternMatcher.ts' />

/// <reference path='signatureHelp.ts' />

/// <reference path='utilities.ts' />

/// <reference path='formatting\formatting.ts' />

/// <reference path='formatting\smartIndenter.ts' />

namespace ts {

/** The version of the language service API */

export let servicesVersion = "0.4"

export interface Node {

getSourceFile(): SourceFile;

getChildCount(sourceFile?: SourceFile): number;

getChildAt(index: number, sourceFile?: SourceFile): Node;

getChildren(sourceFile?: SourceFile): Node[];

getStart(sourceFile?: SourceFile): number;

getFullStart(): number;

getEnd(): number;

getWidth(sourceFile?: SourceFile): number;

getFullWidth(): number;

getLeadingTriviaWidth(sourceFile?: SourceFile): number;

getFullText(sourceFile?: SourceFile): string;

getText(sourceFile?: SourceFile): string;

getFirstToken(sourceFile?: SourceFile): Node;

getLastToken(sourceFile?: SourceFile): Node;

}

export interface Symbol {

getFlags(): SymbolFlags;

getName(): string;

getDeclarations(): Declaration[];

getDocumentationComment(): SymbolDisplayPart[];

}

export interface Type {

getFlags(): TypeFlags;

getSymbol(): Symbol;

getProperties(): Symbol[];

getProperty(propertyName: string): Symbol;

getApparentProperties(): Symbol[];

getCallSignatures(): Signature[];

getConstructSignatures(): Signature[];

getStringIndexType(): Type;

getNumberIndexType(): Type;

getBaseTypes(): ObjectType[]

}

export interface Signature {

getDeclaration(): SignatureDeclaration;

getTypeParameters(): Type[];

getParameters(): Symbol[];

getReturnType(): Type;

getDocumentationComment(): SymbolDisplayPart[];

}

export interface SourceFile {

/* @internal */ version: string;

/* @internal */ scriptSnapshot: IScriptSnapshot;

/* @internal */ nameTable: Map<string>;

/* @internal */ getNamedDeclarations(): Map<Declaration[]>;

getLineAndCharacterOfPosition(pos: number): LineAndCharacter;

getLineStarts(): number[];

getPositionOfLineAndCharacter(line: number, character: number): number;

update(newText: string, textChangeRange: TextChangeRange): SourceFile;

}

/**

* Represents an immutable snapshot of a script at a specified time.Once acquired, the

* snapshot is observably immutable. i.e. the same calls with the same parameters will return

* the same values.

*/

export interface IScriptSnapshot {

/** Gets a portion of the script snapshot specified by [start, end). */

getText(start: number, end: number): string;

/** Gets the length of this script snapshot. */

getLength(): number;

/**

* Gets the TextChangeRange that describe how the text changed between this text and

* an older version. This information is used by the incremental parser to determine

* what sections of the script need to be re-parsed. 'undefined' can be returned if the

* change range cannot be determined. However, in that case, incremental parsing will

* not happen and the entire document will be re - parsed.

*/

getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;

/** Releases all resources held by this script snapshot */

dispose?(): void;

}

export module ScriptSnapshot {

class StringScriptSnapshot implements IScriptSnapshot {

constructor(private text: string) {

}

public getText(start: number, end: number): string {

return this.text.substring(start, end);

}

public getLength(): number {

return this.text.length;

}

public getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange {

// Text-based snapshots do not support incremental parsing. Return undefined

// to signal that to the caller.

return undefined;

}

}

export function fromString(text: string): IScriptSnapshot {

return new StringScriptSnapshot(text);

}

}

export interface PreProcessedFileInfo {

referencedFiles: FileReference[];

importedFiles: FileReference[];

ambientExternalModules: string[];

isLibFile: boolean

}

let scanner: Scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);

let emptyArray: any[] = [];

const jsDocTagNames = [

"augments",

"author",

"argument",

"borrows",

"class",

"constant",

"constructor",

"constructs",

"default",

"deprecated",

"description",

"event",

"example",

"extends",

"field",

"fileOverview",

"function",

"ignore",

"inner",

"lends",

"link",

"memberOf",

"name",

"namespace",

"param",

"private",

"property",

"public",

"requires",

"returns",

"see",

"since",

"static",

"throws",

"type",

"version"

];

let jsDocCompletionEntries: CompletionEntry[];

function createNode(kind: SyntaxKind, pos: number, end: number, flags: NodeFlags, parent?: Node): NodeObject {

let node = <NodeObject> new (getNodeConstructor(kind))();

node.pos = pos;

node.end = end;

node.flags = flags;

node.parent = parent;

return node;

}

class NodeObject implements Node {

public kind: SyntaxKind;

public pos: number;

public end: number;

public flags: NodeFlags;

public parent: Node;

private _children: Node[];

public getSourceFile(): SourceFile {

return getSourceFileOfNode(this);

}

public getStart(sourceFile?: SourceFile): number {

return getTokenPosOfNode(this, sourceFile);

}

public getFullStart(): number {

return this.pos;

}

public getEnd(): number {

return this.end;

}

public getWidth(sourceFile?: SourceFile): number {

return this.getEnd() - this.getStart(sourceFile);

}

public getFullWidth(): number {

return this.end - this.pos;

}

public getLeadingTriviaWidth(sourceFile?: SourceFile): number {

return this.getStart(sourceFile) - this.pos;

}

public getFullText(sourceFile?: SourceFile): string {

return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);

}

public getText(sourceFile?: SourceFile): string {

return (sourceFile || this.getSourceFile()).text.substring(this.getStart(), this.getEnd());

}

private addSyntheticNodes(nodes: Node[], pos: number, end: number): number {

scanner.setTextPos(pos);

while (pos < end) {

let token = scanner.scan();

let textPos = scanner.getTextPos();

nodes.push(createNode(token, pos, textPos, NodeFlags.Synthetic, this));

pos = textPos;

}

return pos;

}

private createSyntaxList(nodes: NodeArray<Node>): Node {

let list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, NodeFlags.Synthetic, this);

list._children = [];

let pos = nodes.pos;

for (let node of nodes) {

if (pos < node.pos) {

pos = this.addSyntheticNodes(list._children, pos, node.pos);

}

list._children.push(node);

pos = node.end;

}

if (pos < nodes.end) {

this.addSyntheticNodes(list._children, pos, nodes.end);

}

return list;

}

private createChildren(sourceFile?: SourceFile) {

let children: Node[];

if (this.kind >= SyntaxKind.FirstNode) {

scanner.setText((sourceFile || this.getSourceFile()).text);

children = [];

let pos = this.pos;

let processNode = (node: Node) => {

if (pos < node.pos) {

pos = this.addSyntheticNodes(children, pos, node.pos);

}

children.push(node);

pos = node.end;

};

let processNodes = (nodes: NodeArray<Node>) => {

if (pos < nodes.pos) {

pos = this.addSyntheticNodes(children, pos, nodes.pos);

}

children.push(this.createSyntaxList(<NodeArray<Node>>nodes));

pos = nodes.end;

};

forEachChild(this, processNode, processNodes);

if (pos < this.end) {

this.addSyntheticNodes(children, pos, this.end);

}

scanner.setText(undefined);

}

this._children = children || emptyArray;

}

public getChildCount(sourceFile?: SourceFile): number {

if (!this._children) this.createChildren(sourceFile);

return this._children.length;

}

public getChildAt(index: number, sourceFile?: SourceFile): Node {

if (!this._children) this.createChildren(sourceFile);

return this._children[index];

}

public getChildren(sourceFile?: SourceFile): Node[] {

if (!this._children) this.createChildren(sourceFile);

return this._children;

}

public getFirstToken(sourceFile?: SourceFile): Node {

let children = this.getChildren(sourceFile);

if (!children.length) {

return undefined;

}

let child = children[0];

return child.kind < SyntaxKind.FirstNode ? child : child.getFirstToken(sourceFile);

}

public getLastToken(sourceFile?: SourceFile): Node {

let children = this.getChildren(sourceFile);

let child = lastOrUndefined(children);

if (!child) {

return undefined;

}

return child.kind < SyntaxKind.FirstNode ? child : child.getLastToken(sourceFile);

}

}

class SymbolObject implements Symbol {

flags: SymbolFlags;

name: string;

declarations: Declaration[];

// Undefined is used to indicate the value has not been computed. If, after computing, the

// symbol has no doc comment, then the empty string will be returned.

documentationComment: SymbolDisplayPart[];

constructor(flags: SymbolFlags, name: string) {

this.flags = flags;

this.name = name;

}

getFlags(): SymbolFlags {

return this.flags;

}

getName(): string {

return this.name;

}

getDeclarations(): Declaration[] {

return this.declarations;

}

getDocumentationComment(): SymbolDisplayPart[] {

if (this.documentationComment === undefined) {

this.documentationComment = getJsDocCommentsFromDeclarations(this.declarations, this.name, !(this.flags & SymbolFlags.Property));

}

return this.documentationComment;

}

}

function getJsDocCommentsFromDeclarations(declarations: Declaration[], name: string, canUseParsedParamTagComments: boolean) {

let documentationComment = <SymbolDisplayPart[]>[];

let docComments = getJsDocCommentsSeparatedByNewLines();

ts.forEach(docComments, docComment => {

if (documentationComment.length) {

documentationComment.push(lineBreakPart());

}

documentationComment.push(docComment);

});

return documentationComment;

function getJsDocCommentsSeparatedByNewLines() {

let paramTag = "@param";

let jsDocCommentParts: SymbolDisplayPart[] = [];

ts.forEach(declarations, (declaration, indexOfDeclaration) => {

// Make sure we are collecting doc comment from declaration once,

// In case of union property there might be same declaration multiple times

// which only varies in type parameter

// Eg. let a: Array<string> | Array<number>; a.length

// The property length will have two declarations of property length coming

// from Array<T> - Array<string> and Array<number>

if (indexOf(declarations, declaration) === indexOfDeclaration) {

let sourceFileOfDeclaration = getSourceFileOfNode(declaration);

// If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments

if (canUseParsedParamTagComments && declaration.kind === SyntaxKind.Parameter) {

ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), jsDocCommentTextRange => {

let cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);

if (cleanedParamJsDocComment) {

addRange(jsDocCommentParts, cleanedParamJsDocComment);

}

});

}

// If this is left side of dotted module declaration, there is no doc comments associated with this node

if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {

return;

}

// If this is dotted module name, get the doc comments from the parent

while (declaration.kind === SyntaxKind.ModuleDeclaration && declaration.parent.kind === SyntaxKind.ModuleDeclaration) {

declaration = <ModuleDeclaration>declaration.parent;

}

// Get the cleaned js doc comment text from the declaration

ts.forEach(getJsDocCommentTextRange(

declaration.kind === SyntaxKind.VariableDeclaration ? declaration.parent.parent : declaration, sourceFileOfDeclaration), jsDocCommentTextRange => {

let cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);

if (cleanedJsDocComment) {

addRange(jsDocCommentParts, cleanedJsDocComment);

}

});

}

});

return jsDocCommentParts;

function getJsDocCommentTextRange(node: Node, sourceFile: SourceFile): TextRange[] {

return ts.map(getJsDocComments(node, sourceFile),

jsDocComment => {

return {

pos: jsDocComment.pos + "/*".length, // Consume /* from the comment

end: jsDocComment.end - "*/".length // Trim off comment end indicator

};

});

}

function consumeWhiteSpacesOnTheLine(pos: number, end: number, sourceFile: SourceFile, maxSpacesToRemove?: number) {

if (maxSpacesToRemove !== undefined) {

end = Math.min(end, pos + maxSpacesToRemove);

}

for (; pos < end; pos++) {

let ch = sourceFile.text.charCodeAt(pos);

if (!isWhiteSpace(ch) || isLineBreak(ch)) {

// Either found lineBreak or non whiteSpace

return pos;

}

}

return end;

}

function consumeLineBreaks(pos: number, end: number, sourceFile: SourceFile) {

while (pos < end && isLineBreak(sourceFile.text.charCodeAt(pos))) {

pos++;

}

return pos;

}

function isName(pos: number, end: number, sourceFile: SourceFile, name: string) {

return pos + name.length < end &&

sourceFile.text.substr(pos, name.length) === name &&

(isWhiteSpace(sourceFile.text.charCodeAt(pos + name.length)) ||

isLineBreak(sourceFile.text.charCodeAt(pos + name.length)));

}

function isParamTag(pos: number, end: number, sourceFile: SourceFile) {

// If it is @param tag

return isName(pos, end, sourceFile, paramTag);

}

function pushDocCommentLineText(docComments: SymbolDisplayPart[], text: string, blankLineCount: number) {

// Add the empty lines in between texts

while (blankLineCount--) {

docComments.push(textPart(""));

}

docComments.push(textPart(text));

}

function getCleanedJsDocComment(pos: number, end: number, sourceFile: SourceFile) {

let spacesToRemoveAfterAsterisk: number;

let docComments: SymbolDisplayPart[] = [];

let blankLineCount = 0;

let isInParamTag = false;

while (pos < end) {

let docCommentTextOfLine = "";

// First consume leading white space

pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile);

// If the comment starts with '*' consume the spaces on this line

if (pos < end && sourceFile.text.charCodeAt(pos) === CharacterCodes.asterisk) {

let lineStartPos = pos + 1;

pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, spacesToRemoveAfterAsterisk);

// Set the spaces to remove after asterisk as margin if not already set

if (spacesToRemoveAfterAsterisk === undefined && pos < end && !isLineBreak(sourceFile.text.charCodeAt(pos))) {

spacesToRemoveAfterAsterisk = pos - lineStartPos;

}

}

else if (spacesToRemoveAfterAsterisk === undefined) {

spacesToRemoveAfterAsterisk = 0;

}

// Analyse text on this line

while (pos < end && !isLineBreak(sourceFile.text.charCodeAt(pos))) {

let ch = sourceFile.text.charAt(pos);

if (ch === "@") {

// If it is @param tag

if (isParamTag(pos, end, sourceFile)) {

isInParamTag = true;

pos += paramTag.length;

continue;

}

else {

isInParamTag = false;

}

}

// Add the ch to doc text if we arent in param tag

if (!isInParamTag) {

docCommentTextOfLine += ch;

}

// Scan next character

pos++;

}

// Continue with next line

pos = consumeLineBreaks(pos, end, sourceFile);

if (docCommentTextOfLine) {

pushDocCommentLineText(docComments, docCommentTextOfLine, blankLineCount);

blankLineCount = 0;

}

else if (!isInParamTag && docComments.length) {

// This is blank line when there is text already parsed

blankLineCount++;

}

}

return docComments;

}

function getCleanedParamJsDocComment(pos: number, end: number, sourceFile: SourceFile) {

let paramHelpStringMargin: number;

let paramDocComments: SymbolDisplayPart[] = [];

while (pos < end) {

if (isParamTag(pos, end, sourceFile)) {

let blankLineCount = 0;

let recordedParamTag = false;

// Consume leading spaces

pos = consumeWhiteSpaces(pos + paramTag.length);

if (pos >= end) {

break;

}

// Ignore type expression

if (sourceFile.text.charCodeAt(pos) === CharacterCodes.openBrace) {

pos++;

for (let curlies = 1; pos < end; pos++) {

let charCode = sourceFile.text.charCodeAt(pos);

// { character means we need to find another } to match the found one

if (charCode === CharacterCodes.openBrace) {

curlies++;

continue;

}

// } char

if (charCode === CharacterCodes.closeBrace) {

curlies--;

if (curlies === 0) {

// We do not have any more } to match the type expression is ignored completely

pos++;

break;

}

else {

// there are more { to be matched with }

continue;

}

}

// Found start of another tag

if (charCode === CharacterCodes.at) {

break;

}

}

// Consume white spaces

pos = consumeWhiteSpaces(pos);

if (pos >= end) {

break;

}

}

// Parameter name

if (isName(pos, end, sourceFile, name)) {

// Found the parameter we are looking for consume white spaces

pos = consumeWhiteSpaces(pos + name.length);

if (pos >= end) {

break;

}

let paramHelpString = "";

let firstLineParamHelpStringPos = pos;

while (pos < end) {

let ch = sourceFile.text.charCodeAt(pos);

// at line break, set this comment line text and go to next line

if (isLineBreak(ch)) {

if (paramHelpString) {

pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);

paramHelpString = "";

blankLineCount = 0;

recordedParamTag = true;

}

else if (recordedParamTag) {

blankLineCount++;

}

// Get the pos after cleaning start of the line

setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos);

continue;

}

// Done scanning param help string - next tag found

if (ch === CharacterCodes.at) {

break;

}

paramHelpString += sourceFile.text.charAt(pos);

// Go to next character

pos++;

}

// If there is param help text, add it top the doc comments

if (paramHelpString) {

pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);

}

paramHelpStringMargin = undefined;

}

// If this is the start of another tag, continue with the loop in seach of param tag with symbol name

if (sourceFile.text.charCodeAt(pos) === CharacterCodes.at) {

continue;

}

}

// Next character

pos++;

}

return paramDocComments;

function consumeWhiteSpaces(pos: number) {

while (pos < end && isWhiteSpace(sourceFile.text.charCodeAt(pos))) {

pos++;

}

return pos;

}

function setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos: number) {

// Get the pos after consuming line breaks

pos = consumeLineBreaks(pos, end, sourceFile);

if (pos >= end) {

return;

}

if (paramHelpStringMargin === undefined) {

paramHelpStringMargin = sourceFile.getLineAndCharacterOfPosition(firstLineParamHelpStringPos).character;

}

// Now consume white spaces max

let startOfLinePos = pos;

pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile, paramHelpStringMargin);

if (pos >= end) {

return;

}

let consumedSpaces = pos - startOfLinePos;

if (consumedSpaces < paramHelpStringMargin) {

let ch = sourceFile.text.charCodeAt(pos);

if (ch === CharacterCodes.asterisk) {

// Consume more spaces after asterisk

pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, paramHelpStringMargin - consumedSpaces - 1);

}

}

}

}

}

}

class TypeObject implements Type {

checker: TypeChecker;

flags: TypeFlags;

id: number;

symbol: Symbol;

constructor(checker: TypeChecker, flags: TypeFlags) {

this.checker = checker;

this.flags = flags;

}

getFlags(): TypeFlags {

return this.flags;

}

getSymbol(): Symbol {

return this.symbol;

}

getProperties(): Symbol[] {

return this.checker.getPropertiesOfType(this);

}

getProperty(propertyName: string): Symbol {

return this.checker.getPropertyOfType(this, propertyName);

}

getApparentProperties(): Symbol[] {

return this.checker.getAugmentedPropertiesOfType(this);

}

getCallSignatures(): Signature[] {

return this.checker.getSignaturesOfType(this, SignatureKind.Call);

}

getConstructSignatures(): Signature[] {

return this.checker.getSignaturesOfType(this, SignatureKind.Construct);

}

getStringIndexType(): Type {

return this.checker.getIndexTypeOfType(this, IndexKind.String);

}

getNumberIndexType(): Type {

return this.checker.getIndexTypeOfType(this, IndexKind.Number);

}

getBaseTypes(): ObjectType[] {

return this.flags & (TypeFlags.Class | TypeFlags.Interface)

? this.checker.getBaseTypes(<InterfaceType><Type>this)

: undefined;

}

}

class SignatureObject implements Signature {

checker: TypeChecker;

declaration: SignatureDeclaration;

typeParameters: TypeParameter[];

parameters: Symbol[];

resolvedReturnType: Type;

minArgumentCount: number;

hasRestParameter: boolean;

hasStringLiterals: boolean;

// Undefined is used to indicate the value has not been computed. If, after computing, the

// symbol has no doc comment, then the empty string will be returned.

documentationComment: SymbolDisplayPart[];

constructor(checker: TypeChecker) {

this.checker = checker;

}

getDeclaration(): SignatureDeclaration {

return this.declaration;

}

getTypeParameters(): Type[] {

return this.typeParameters;

}

getParameters(): Symbol[] {

return this.parameters;

}

getReturnType(): Type {

return this.checker.getReturnTypeOfSignature(this);

}

getDocumentationComment(): SymbolDisplayPart[] {

if (this.documentationComment === undefined) {

this.documentationComment = this.declaration ? getJsDocCommentsFromDeclarations(

[this.declaration],

/*name*/ undefined,

/*canUseParsedParamTagComments*/ false) : [];

}

return this.documentationComment;

}

}

class SourceFileObject extends NodeObject implements SourceFile {

public _declarationBrand: any;

public fileName: string;

public text: string;

public scriptSnapshot: IScriptSnapshot;

public lineMap: number[];

public statements: NodeArray<Statement>;

public endOfFileToken: Node;

public amdDependencies: { name: string; path: string }[];

public moduleName: string;

public referencedFiles: FileReference[];

public syntacticDiagnostics: Diagnostic[];

public referenceDiagnostics: Diagnostic[];

public parseDiagnostics: Diagnostic[];

public bindDiagnostics: Diagnostic[];

public isDefaultLib: boolean;

public hasNoDefaultLib: boolean;

public externalModuleIndicator: Node; // The first node that causes this file to be an external module

public nodeCount: number;

public identifierCount: number;

public symbolCount: number;

public version: string;

public languageVersion: ScriptTarget;

public languageVariant: LanguageVariant;

public identifiers: Map<string>;

public nameTable: Map<string>;

public resolvedModules: Map<ResolvedModule>;

public imports: LiteralExpression[];

private namedDeclarations: Map<Declaration[]>;

public update(newText: string, textChangeRange: TextChangeRange): SourceFile {

return updateSourceFile(this, newText, textChangeRange);

}

public getLineAndCharacterOfPosition(position: number): LineAndCharacter {

return ts.getLineAndCharacterOfPosition(this, position);

}

public getLineStarts(): number[] {

return getLineStarts(this);

}

public getPositionOfLineAndCharacter(line: number, character: number): number {

return ts.getPositionOfLineAndCharacter(this, line, character);

}

public getNamedDeclarations(): Map<Declaration[]> {

if (!this.namedDeclarations) {

this.namedDeclarations = this.computeNamedDeclarations();

}

return this.namedDeclarations;

}

private computeNamedDeclarations(): Map<Declaration[]> {

let result: Map<Declaration[]> = {};

forEachChild(this, visit);

return result;

function addDeclaration(declaration: Declaration) {

let name = getDeclarationName(declaration);

if (name) {

let declarations = getDeclarations(name);

declarations.push(declaration);

}

}

function getDeclarations(name: string) {

return getProperty(result, name) || (result[name] = []);

}

function getDeclarationName(declaration: Declaration) {

if (declaration.name) {

let result = getTextOfIdentifierOrLiteral(declaration.name);

if (result !== undefined) {

return result;

}

if (declaration.name.kind === SyntaxKind.ComputedPropertyName) {

let expr = (<ComputedPropertyName>declaration.name).expression;

if (expr.kind === SyntaxKind.PropertyAccessExpression) {

return (<PropertyAccessExpression>expr).name.text;

}

return getTextOfIdentifierOrLiteral(expr);

}

}

return undefined;

}

function getTextOfIdentifierOrLiteral(node: Node) {

if (node) {

if (node.kind === SyntaxKind.Identifier ||

node.kind === SyntaxKind.StringLiteral ||

node.kind === SyntaxKind.NumericLiteral) {

return (<Identifier | LiteralExpression>node).text;

}

}

return undefined;

}

function visit(node: Node): void {

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

let functionDeclaration = <FunctionLikeDeclaration>node;

let declarationName = getDeclarationName(functionDeclaration);

if (declarationName) {

let declarations = getDeclarations(declarationName);

let lastDeclaration = lastOrUndefined(declarations);

// Check whether this declaration belongs to an "overload group".

if (lastDeclaration && functionDeclaration.parent === lastDeclaration.parent && functionDeclaration.symbol === lastDeclaration.symbol) {

// Overwrite the last declaration if it was an overload

// and this one is an implementation.

if (functionDeclaration.body && !(<FunctionLikeDeclaration>lastDeclaration).body) {

declarations[declarations.length - 1] = functionDeclaration;

}

}

else {

declarations.push(functionDeclaration);

}

forEachChild(node, visit);

}

break;

case SyntaxKind.ClassDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.EnumDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ExportSpecifier:

case SyntaxKind.ImportSpecifier:

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ImportClause:

case SyntaxKind.NamespaceImport:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.TypeLiteral:

addDeclaration(<Declaration>node);

// fall through

case SyntaxKind.Constructor:

case SyntaxKind.VariableStatement:

case SyntaxKind.VariableDeclarationList:

case SyntaxKind.ObjectBindingPattern:

case SyntaxKind.ArrayBindingPattern:

case SyntaxKind.ModuleBlock:

forEachChild(node, visit);

break;

case SyntaxKind.Block:

if (isFunctionBlock(node)) {

forEachChild(node, visit);

}

break;

case SyntaxKind.Parameter:

// Only consider properties defined as constructor parameters

if (!(node.flags & NodeFlags.AccessibilityModifier)) {

break;

}

// fall through

case SyntaxKind.VariableDeclaration:

case SyntaxKind.BindingElement:

if (isBindingPattern((<VariableDeclaration>node).name)) {

forEachChild((<VariableDeclaration>node).name, visit);

break;

}

case SyntaxKind.EnumMember:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

addDeclaration(<Declaration>node);

break;

case SyntaxKind.ExportDeclaration:

// Handle named exports case e.g.:

// export {a, b as B} from "mod";

if ((<ExportDeclaration>node).exportClause) {

forEach((<ExportDeclaration>node).exportClause.elements, visit);

}

break;

case SyntaxKind.ImportDeclaration:

let importClause = (<ImportDeclaration>node).importClause;

if (importClause) {

// Handle default import case e.g.:

// import d from "mod";

if (importClause.name) {

addDeclaration(importClause);

}

// Handle named bindings in imports e.g.:

// import * as NS from "mod";

// import {a, b as B} from "mod";

if (importClause.namedBindings) {

if (importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {

addDeclaration(<NamespaceImport>importClause.namedBindings);

}

else {

forEach((<NamedImports>importClause.namedBindings).elements, visit);

}

}

}

break;

}

}

}

}

export interface HostCancellationToken {

isCancellationRequested(): boolean;

}