export var 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;

}

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

getNamedDeclarations(): Declaration[];

getLineAndCharacterOfPosition(pos: number): LineAndCharacter;

getLineStarts(): number[];

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

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

}

/**

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;

/**

getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;

}

export module ScriptSnapshot {

class StringScriptSnapshot implements IScriptSnapshot {

private _lineStartPositions: number[] = undefined;

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

isLibFile: boolean

}

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

var emptyArray: any[] = [];

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

var 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.getFullStart();

}

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

var token = scanner.scan();

var textPos = scanner.getTextPos();

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

pos = textPos;

}

return pos;

}

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

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

list._children = [];

var pos = nodes.pos;

for (var i = 0, len = nodes.length; i < len; i++) {

var node = nodes[i];

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

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

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

var children: Node[] = [];

var pos = this.pos;

var processNode = (node: Node) => {

if (pos < node.pos) {

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

}

children.push(node);

pos = node.end;

};

var 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 {

var children = this.getChildren();

for (var i = 0; i < children.length; i++) {

var child = children[i];

if (child.kind < SyntaxKind.FirstNode) {

return child;

}

return child.getFirstToken(sourceFile);

}

}

public getLastToken(sourceFile?: SourceFile): Node {

var children = this.getChildren(sourceFile);

for (var i = children.length - 1; i >= 0; i--) {

var child = children[i];

if (child.kind < SyntaxKind.FirstNode) {

return child;

}

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

var documentationComment = <SymbolDisplayPart[]>[];

var docComments = getJsDocCommentsSeparatedByNewLines();

ts.forEach(docComments, docComment => {

if (documentationComment.length) {

documentationComment.push(lineBreakPart());

}

documentationComment.push(docComment);

});

return documentationComment;

function getJsDocCommentsSeparatedByNewLines() {

var paramTag = "@param";

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

var 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 => {

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

if (cleanedParamJsDocComment) {

jsDocCommentParts.push.apply(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 => {

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

if (cleanedJsDocComment) {

jsDocCommentParts.push.apply(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++) {

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

var spacesToRemoveAfterAsterisk: number;

var docComments: SymbolDisplayPart[] = [];

var blankLineCount = 0;

var isInParamTag = false;

while (pos < end) {

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

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

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

var paramHelpStringMargin: number;

var paramDocComments: SymbolDisplayPart[] = [];

while (pos < end) {

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

var blankLineCount = 0;

var 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 (var curlies = 1; pos < end; pos++) {

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

}

var paramHelpString = "";

var firstLineParamHelpStringPos = pos;

while (pos < end) {

var 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

var startOfLinePos = pos;

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

if (pos >= end) {

return;

}

var consumedSpaces = pos - startOfLinePos;

if (consumedSpaces < paramHelpStringMargin) {

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

}

}

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 amdModuleName: string;

public referencedFiles: FileReference[];

public syntacticDiagnostics: Diagnostic[];

public referenceDiagnostics: Diagnostic[];

public parseDiagnostics: Diagnostic[];

public bindDiagnostics: Diagnostic[];

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 identifiers: Map<string>;

public nameTable: Map<string>;

private namedDeclarations: 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() {

if (!this.namedDeclarations) {

var sourceFile = this;

var namedDeclarations: Declaration[] = [];

forEachChild(sourceFile, function visit(node: Node): void {

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

var functionDeclaration = <FunctionLikeDeclaration>node;

if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) {

var lastDeclaration = namedDeclarations.length > 0 ?

namedDeclarations[namedDeclarations.length - 1] :

undefined;

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

if (lastDeclaration && 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) {

namedDeclarations[namedDeclarations.length - 1] = functionDeclaration;

}

}

else {

namedDeclarations.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:

if ((<Declaration>node).name) {

namedDeclarations.push(<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: