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

/// <reference path="..\compiler\commandLineParser.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='jsTyping.ts' />

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

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

namespace ts {

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

export const servicesVersion = "0.5";

export interface Node {

getSourceFile(): SourceFile;

getChildCount(sourceFile?: SourceFile): number;

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

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

getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): 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[];

getNonNullableType(): Type;

}

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<number>;

/* @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 namespace 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[];

typeReferenceDirectives: FileReference[];

importedFiles: FileReference[];

ambientExternalModules: string[];

isLibFile: boolean;

}

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

const 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",

"typedef",

"property",

"prop",

"version"

];

let jsDocCompletionEntries: CompletionEntry[];

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

const node = new NodeObject(kind, pos, 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;

public jsDocComments: JSDocComment[];

private _children: Node[];

constructor(kind: SyntaxKind, pos: number, end: number) {

this.kind = kind;

this.pos = pos;

this.end = end;

this.flags = NodeFlags.None;

this.parent = undefined;

}

public getSourceFile(): SourceFile {

return getSourceFileOfNode(this);

}

public getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number {

return getTokenPosOfNode(this, sourceFile, includeJsDocComment);

}

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, useJSDocScanner?: boolean): number {

scanner.setTextPos(pos);

while (pos < end) {

const token = useJSDocScanner ? scanner.scanJSDocToken() : scanner.scan();

const textPos = scanner.getTextPos();

if (textPos <= end) {

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

}

pos = textPos;

}

return pos;

}

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

const list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, 0, this);

list._children = [];

let pos = nodes.pos;

for (const 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;

const useJSDocScanner = this.kind >= SyntaxKind.FirstJSDocTagNode && this.kind <= SyntaxKind.LastJSDocTagNode;

const processNode = (node: Node) => {

if (pos < node.pos) {

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

}

children.push(node);

pos = node.end;

};

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

if (pos < nodes.pos) {

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

}

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

pos = nodes.end;

};

// jsDocComments need to be the first children

if (this.jsDocComments) {

for (const jsDocComment of this.jsDocComments) {

processNode(jsDocComment);

}

}

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 {

const children = this.getChildren(sourceFile);

if (!children.length) {

return undefined;

}

const child = children[0];

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

}

public getLastToken(sourceFile?: SourceFile): Node {

const children = this.getChildren(sourceFile);

const 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) {

const documentationComment = <SymbolDisplayPart[]>[];

const docComments = getJsDocCommentsSeparatedByNewLines();

ts.forEach(docComments, docComment => {

if (documentationComment.length) {

documentationComment.push(lineBreakPart());

}

documentationComment.push(docComment);

});

return documentationComment;

function getJsDocCommentsSeparatedByNewLines() {

const paramTag = "@param";

const 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. const 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) {

const 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) {

if ((declaration.parent.kind === SyntaxKind.FunctionExpression || declaration.parent.kind === SyntaxKind.ArrowFunction) &&

declaration.parent.parent.kind === SyntaxKind.VariableDeclaration) {

addCommentParts(declaration.parent.parent.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);

}

addCommentParts(declaration.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);

}

// 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 && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {

return;

}

if ((declaration.kind === SyntaxKind.FunctionExpression || declaration.kind === SyntaxKind.ArrowFunction) &&

declaration.parent.kind === SyntaxKind.VariableDeclaration) {

addCommentParts(declaration.parent.parent, sourceFileOfDeclaration, getCleanedJsDocComment);

}

// 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;

}

addCommentParts(declaration.kind === SyntaxKind.VariableDeclaration ? declaration.parent.parent : declaration,

sourceFileOfDeclaration,

getCleanedJsDocComment);

if (declaration.kind === SyntaxKind.VariableDeclaration) {

const init = (declaration as VariableDeclaration).initializer;

if (init && (init.kind === SyntaxKind.FunctionExpression || init.kind === SyntaxKind.ArrowFunction)) {

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

addCommentParts(init, sourceFileOfDeclaration, getCleanedJsDocComment);

}

}

}

});

return jsDocCommentParts;

function addCommentParts(commented: Node,

sourceFileOfDeclaration: SourceFile,

getCommentPart: (pos: number, end: number, file: SourceFile) => SymbolDisplayPart[]): void {

const ranges = getJsDocCommentTextRange(commented, sourceFileOfDeclaration);

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

ts.forEach(ranges, jsDocCommentTextRange => {

const cleanedComment = getCommentPart(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);

if (cleanedComment) {

addRange(jsDocCommentParts, cleanedComment);

}

});

}

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++) {

const 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) {

blankLineCount--;

docComments.push(textPart(""));

}

docComments.push(textPart(text));

}

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

let spacesToRemoveAfterAsterisk: number;

const 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) {

const 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;

}

// Analyze text on this line

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

const 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;

const 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++) {

const 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 = "";

const firstLineParamHelpStringPos = pos;

while (pos < end) {

const 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 search 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

const startOfLinePos = pos;

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

if (pos >= end) {

return;

}

const consumedSpaces = pos - startOfLinePos;

if (consumedSpaces < paramHelpStringMargin) {

const 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;

}

getNonNullableType(): Type {

return this.checker.getNonNullableType(this);

}

}

class SignatureObject implements Signature {

checker: TypeChecker;

declaration: SignatureDeclaration;

typeParameters: TypeParameter[];

parameters: Symbol[];

thisParameter: 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 path: Path;

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 typeReferenceDirectives: FileReference[];

public syntacticDiagnostics: Diagnostic[];

public referenceDiagnostics: Diagnostic[];

public parseDiagnostics: Diagnostic[];

public bindDiagnostics: Diagnostic[];

public isDeclarationFile: boolean;

public isDefaultLib: boolean;

public hasNoDefaultLib: boolean;

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

public commonJsModuleIndicator: Node; // The first node that causes this file to be a CommonJS module

public nodeCount: number;

public identifierCount: number;

public symbolCount: number;

public version: string;

public scriptKind: ScriptKind;

public languageVersion: ScriptTarget;

public languageVariant: LanguageVariant;

public identifiers: Map<string>;

public nameTable: Map<number>;

public resolvedModules: Map<ResolvedModule>;

public resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective>;

public imports: LiteralExpression[];

public moduleAugmentations: LiteralExpression[];

private namedDeclarations: Map<Declaration[]>;

constructor(kind: SyntaxKind, pos: number, end: number) {

super(kind, pos, end);

}

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[]> {

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

forEachChild(this, visit);

return result;

function addDeclaration(declaration: Declaration) {

const name = getDeclarationName(declaration);

if (name) {

const declarations = getDeclarations(name);

declarations.push(declaration);

}

}

function getDeclarations(name: string) {

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

}

function getDeclarationName(declaration: Declaration) {

if (declaration.name) {

const result = getTextOfIdentifierOrLiteral(declaration.name);

if (result !== undefined) {

return result;

}

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

const 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.FunctionExpression:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

const functionDeclaration = <FunctionLikeDeclaration>node;

const declarationName = getDeclarationName(functionDeclaration);

if (declarationName) {

const declarations = getDeclarations(declarationName);

const 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.ClassExpression:

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);

forEachChild(node, visit);

break;

case SyntaxKind.Parameter:

// Only consider parameter properties

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

break;

}

// fall through

case SyntaxKind.VariableDeclaration:

case SyntaxKind.BindingElement: {

const decl = <VariableDeclaration> node;

if (isBindingPattern(decl.name)) {

forEachChild(decl.name, visit);

break;