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;

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 {

getSourceUnit(): TypeScript.SourceUnitSyntax;

getSyntaxTree(): TypeScript.SyntaxTree;

getScriptSnapshot(): TypeScript.IScriptSnapshot;

getNamedDeclarations(): Declaration[];

update(scriptSnapshot: TypeScript.IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TypeScript.TextChangeRange): SourceFile;

}

var scanner: Scanner = createScanner(ScriptTarget.ES5, /*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);

}

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

scanner.setTextPos(pos);

while (pos < end) {

var token = scanner.scan();

var textPos = scanner.getTextPos();

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

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.Missing) return child;

if (child.kind > SyntaxKind.Missing) 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.Missing) return child;

if (child.kind > SyntaxKind.Missing) 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 => {

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 = declaration.parent;

}

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

ts.forEach(getJsDocCommentTextRange(

declaration.kind === SyntaxKind.VariableDeclaration ? declaration.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));

}

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

// If it is @param tag

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

}

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

var spacesToRemoveAfterAsterisk: number;

var docComments: SymbolDisplayPart[] = [];

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

docComments.push(textPart(docCommentTextOfLine));

}

}

return docComments;

}

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

var paramHelpStringMargin: number;

var paramDocComments: SymbolDisplayPart[] = [];

while (pos < end) {

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

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

paramDocComments.push(textPart(paramHelpString));

paramHelpString = "";

}

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

paramDocComments.push(textPart(paramHelpString));

}

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.getLineAndCharacterFromPosition(firstLineParamHelpStringPos).character - 1;

}

// 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.getAugmentedPropertiesOfApparentType(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],

this.declaration.name ? this.declaration.name.text : "",

/*canUseParsedParamTagComments*/ false) : [];

}

return this.documentationComment;

}

}

var incrementalParse: IncrementalParse = TypeScript.IncrementalParser.parse;

class SourceFileObject extends NodeObject implements SourceFile {

public filename: string;

public text: string;

public getLineAndCharacterFromPosition(position: number): { line: number; character: number } { return null; }

public getPositionFromLineAndCharacter(line: number, character: number): number { return -1; }

public amdDependencies: string[];

public referencedFiles: FileReference[];

public syntacticErrors: Diagnostic[];

public semanticErrors: 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 statements: NodeArray<Statement>;

public version: string;

public isOpen: boolean;

public languageVersion: ScriptTarget;

public identifiers: Map<string>;

private syntaxTree: TypeScript.SyntaxTree;

private scriptSnapshot: TypeScript.IScriptSnapshot;

private namedDeclarations: Declaration[];

public getSourceUnit(): TypeScript.SourceUnitSyntax {

// If we don't have a script, create one from our parse tree.

return this.getSyntaxTree().sourceUnit();

}

public getScriptSnapshot(): TypeScript.IScriptSnapshot {

return this.scriptSnapshot;

}

public getLineMap(): TypeScript.LineMap {

return this.getSyntaxTree().lineMap();

}

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

var functionDeclaration = <FunctionDeclaration>node;

if (functionDeclaration.name && functionDeclaration.name.kind !== SyntaxKind.Missing) {

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 && !(<FunctionDeclaration>lastDeclaration).body) {

namedDeclarations[namedDeclarations.length - 1] = functionDeclaration;

}

}

else {

namedDeclarations.push(node);

}

forEachChild(node, visit);

}

break;

case SyntaxKind.ClassDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.EnumDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.ImportDeclaration:

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

case SyntaxKind.FunctionBlock:

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

case SyntaxKind.Property:

namedDeclarations.push(<Declaration>node);

break;

}

});

this.namedDeclarations = namedDeclarations;

}

return this.namedDeclarations;

}

public getSyntaxTree(): TypeScript.SyntaxTree {

if (!this.syntaxTree) {

var start = new Date().getTime();

this.syntaxTree = TypeScript.Parser.parse(

this.filename, TypeScript.SimpleText.fromScriptSnapshot(this.scriptSnapshot), this.languageVersion, this.isDeclareFile());

var time = new Date().getTime() - start;

//TypeScript.syntaxTreeParseTime += time;

}

return this.syntaxTree;

}

private isDeclareFile(): boolean {

return TypeScript.isDTSFile(this.filename);

}

public update(scriptSnapshot: TypeScript.IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TypeScript.TextChangeRange): SourceFile {

// See if we are currently holding onto a syntax tree. We may not be because we're

// either a closed file, or we've just been lazy and haven't had to create the syntax

// tree yet. Access the field instead of the method so we don't accidentally realize

// the old syntax tree.

var oldSyntaxTree = this.syntaxTree;

if (textChangeRange && Debug.shouldAssert(AssertionLevel.Normal)) {

var oldText = this.scriptSnapshot;

var newText = scriptSnapshot;

TypeScript.Debug.assert((oldText.getLength() - textChangeRange.span().length() + textChangeRange.newLength()) === newText.getLength());

if (Debug.shouldAssert(AssertionLevel.VeryAggressive)) {

var oldTextPrefix = oldText.getText(0, textChangeRange.span().start());

var newTextPrefix = newText.getText(0, textChangeRange.span().start());

TypeScript.Debug.assert(oldTextPrefix === newTextPrefix);

var oldTextSuffix = oldText.getText(textChangeRange.span().end(), oldText.getLength());

var newTextSuffix = newText.getText(textChangeRange.newSpan().end(), newText.getLength());

TypeScript.Debug.assert(oldTextSuffix === newTextSuffix);

}

}

var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot);

// If we don't have a text change, or we don't have an old syntax tree, then do a full

// parse. Otherwise, do an incremental parse.

var newSyntaxTree = !textChangeRange || !oldSyntaxTree

? TypeScript.Parser.parse(this.filename, text, this.languageVersion, TypeScript.isDTSFile(this.filename))

: TypeScript.IncrementalParser.parse(oldSyntaxTree, textChangeRange, text);

return SourceFileObject.createSourceFileObject(this.filename, scriptSnapshot, this.languageVersion, version, isOpen, newSyntaxTree);

}

public static createSourceFileObject(filename: string, scriptSnapshot: TypeScript.IScriptSnapshot, languageVersion: ScriptTarget, version: string, isOpen: boolean, syntaxTree?: TypeScript.SyntaxTree) {

var newSourceFile = <SourceFileObject><any>createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), languageVersion, version, isOpen);

newSourceFile.scriptSnapshot = scriptSnapshot;

newSourceFile.syntaxTree = syntaxTree;