namespace ts {

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

export const servicesVersion = "0.8";

function createNode<TKind extends SyntaxKind>(kind: TKind, pos: number, end: number, parent: Node): NodeObject | TokenObject<TKind> | IdentifierObject {

const node = isNodeKind(kind) ? new NodeObject(kind, pos, end) :

kind === SyntaxKind.Identifier ? new IdentifierObject(SyntaxKind.Identifier, pos, end) :

new TokenObject(kind, pos, end);

node.parent = parent;

node.flags = parent.flags & NodeFlags.ContextFlags;

return node;

}

class NodeObject implements Node {

public kind: SyntaxKind;

public pos: number;

public end: number;

public flags: NodeFlags;

public parent: Node;

public symbol: Symbol;

public jsDoc: JSDoc[];

public original: Node;

public transformFlags: TransformFlags;

private _children: Node[] | undefined;

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

this.pos = pos;

this.end = end;

this.flags = NodeFlags.None;

this.transformFlags = undefined!; // TODO: GH#18217

this.parent = undefined!;

this.kind = kind;

}

private assertHasRealPosition(message?: string) {

// tslint:disable-next-line:debug-assert

Debug.assert(!positionIsSynthesized(this.pos) && !positionIsSynthesized(this.end), message || "Node must have a real position for this operation");

}

public getSourceFile(): SourceFile {

return getSourceFileOfNode(this);

}

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

this.assertHasRealPosition();

return getTokenPosOfNode(this, sourceFile, includeJsDocComment);

}

public getFullStart(): number {

this.assertHasRealPosition();

return this.pos;

}

public getEnd(): number {

this.assertHasRealPosition();

return this.end;

}

public getWidth(sourceFile?: SourceFile): number {

this.assertHasRealPosition();

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

}

public getFullWidth(): number {

this.assertHasRealPosition();

return this.end - this.pos;

}

public getLeadingTriviaWidth(sourceFile?: SourceFile): number {

this.assertHasRealPosition();

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

}

public getFullText(sourceFile?: SourceFile): string {

this.assertHasRealPosition();

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

}

public getText(sourceFile?: SourceFile): string {

this.assertHasRealPosition();

if (!sourceFile) {

sourceFile = this.getSourceFile();

}

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

}

public getChildCount(sourceFile?: SourceFile): number {

return this.getChildren(sourceFile).length;

}

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

return this.getChildren(sourceFile)[index];

}

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

this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine");

return this._children || (this._children = createChildren(this, sourceFile));

}

public getFirstToken(sourceFile?: SourceFile): Node | undefined {

this.assertHasRealPosition();

const children = this.getChildren(sourceFile);

if (!children.length) {

return undefined;

}

const child = find(children, kid => kid.kind < SyntaxKind.FirstJSDocNode || kid.kind > SyntaxKind.LastJSDocNode)!;

return child.kind < SyntaxKind.FirstNode ?

child :

child.getFirstToken(sourceFile);

}

public getLastToken(sourceFile?: SourceFile): Node | undefined {

this.assertHasRealPosition();

const children = this.getChildren(sourceFile);

const child = lastOrUndefined(children);

if (!child) {

return undefined;

}

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

}

public forEachChild<T>(cbNode: (node: Node) => T, cbNodeArray?: (nodes: NodeArray<Node>) => T): T | undefined {

return forEachChild(this, cbNode, cbNodeArray);

}

}

function createChildren(node: Node, sourceFile: SourceFileLike | undefined): Node[] {

if (!isNodeKind(node.kind)) {

return emptyArray;

}

const children: Node[] = [];

if (isJSDocCommentContainingNode(node)) {

/** Don't add trivia for "tokens" since this is in a comment. */

node.forEachChild(child => { children.push(child); });

return children;

}

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

let pos = node.pos;

const processNode = (child: Node) => {

addSyntheticNodes(children, pos, child.pos, node);

children.push(child);

pos = child.end;

};

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

addSyntheticNodes(children, pos, nodes.pos, node);

children.push(createSyntaxList(nodes, node));

pos = nodes.end;

};

// jsDocComments need to be the first children

forEach((node as JSDocContainer).jsDoc, processNode);

// For syntactic classifications, all trivia are classified together, including jsdoc comments.

// For that to work, the jsdoc comments should still be the leading trivia of the first child.

// Restoring the scanner position ensures that.

pos = node.pos;

node.forEachChild(processNode, processNodes);

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

scanner.setText(undefined);

return children;

}

function addSyntheticNodes(nodes: Push<Node>, pos: number, end: number, parent: Node): void {

scanner.setTextPos(pos);

while (pos < end) {

const token = scanner.scan();

const textPos = scanner.getTextPos();

if (textPos <= end) {

if (token === SyntaxKind.Identifier) {

Debug.fail(`Did not expect ${Debug.showSyntaxKind(parent)} to have an Identifier in its trivia`);

}

nodes.push(createNode(token, pos, textPos, parent));

}

pos = textPos;

if (token === SyntaxKind.EndOfFileToken) {

break;

}

}

}

function createSyntaxList(nodes: NodeArray<Node>, parent: Node): Node {

const list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, parent) as any as SyntaxList;

list._children = [];

let pos = nodes.pos;

for (const node of nodes) {

addSyntheticNodes(list._children, pos, node.pos, parent);

list._children.push(node);

pos = node.end;

}

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

return list;

}

class TokenOrIdentifierObject implements Node {

public kind: SyntaxKind;

public pos: number;

public end: number;

public flags: NodeFlags;

public parent: Node;

public symbol: Symbol;

public jsDocComments: JSDoc[];

public transformFlags: TransformFlags;

constructor(pos: number, end: number) {

// Set properties in same order as NodeObject

this.pos = pos;

this.end = end;

this.flags = NodeFlags.None;

this.parent = undefined!;

}

public getSourceFile(): SourceFile {

return getSourceFileOfNode(this);

}

public getStart(sourceFile?: SourceFileLike, 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 {

if (!sourceFile) {

sourceFile = this.getSourceFile();

}

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

}

public getChildCount(): number {

return 0;

}

public getChildAt(): Node {

return undefined!; // TODO: GH#18217

}

public getChildren(): Node[] {

return this.kind === SyntaxKind.EndOfFileToken ? (this as EndOfFileToken).jsDoc || emptyArray : emptyArray;

}

public getFirstToken(): Node | undefined {

return undefined;

}

public getLastToken(): Node | undefined {

return undefined;

}

public forEachChild<T>(): T | undefined {

return undefined;

}

}

class SymbolObject implements Symbol {

flags: SymbolFlags;

escapedName: __String;

declarations: Declaration[];

valueDeclaration: Declaration;

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

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

documentationComment?: SymbolDisplayPart[];

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

// symbol has no JSDoc tags, then the empty array will be returned.

tags?: JSDocTagInfo[];

constructor(flags: SymbolFlags, name: __String) {

this.flags = flags;

this.escapedName = name;

}

getFlags(): SymbolFlags {

return this.flags;

}

get name(): string {

return symbolName(this);

}

getEscapedName(): __String {

return this.escapedName;

}

getName(): string {

return this.name;

}

getDeclarations(): Declaration[] | undefined {

return this.declarations;

}

getDocumentationComment(checker: TypeChecker | undefined): SymbolDisplayPart[] {

if (!this.documentationComment) {

this.documentationComment = emptyArray; // Set temporarily to avoid an infinite loop finding inherited docs

this.documentationComment = getDocumentationComment(this.declarations, checker);

}

return this.documentationComment;

}

getJsDocTags(): JSDocTagInfo[] {

if (this.tags === undefined) {

this.tags = JsDoc.getJsDocTagsFromDeclarations(this.declarations);

}

return this.tags;

}

}

class TokenObject<TKind extends SyntaxKind> extends TokenOrIdentifierObject implements Token<TKind> {

public symbol: Symbol;

public kind: TKind;

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

super(pos, end);

this.kind = kind;

}

}

class IdentifierObject extends TokenOrIdentifierObject implements Identifier {

public kind: SyntaxKind.Identifier;

public escapedText: __String;

public symbol: Symbol;

public autoGenerateFlags: GeneratedIdentifierFlags;

_primaryExpressionBrand: any;

_memberExpressionBrand: any;

_leftHandSideExpressionBrand: any;

_updateExpressionBrand: any;

_unaryExpressionBrand: any;

_expressionBrand: any;

_declarationBrand: any;

/*@internal*/typeArguments: NodeArray<TypeNode>;

constructor(_kind: SyntaxKind.Identifier, pos: number, end: number) {

super(pos, end);

}

get text(): string {

return idText(this);

}

}

IdentifierObject.prototype.kind = SyntaxKind.Identifier;

class TypeObject implements Type {

checker: TypeChecker;

flags: TypeFlags;

objectFlags?: ObjectFlags;

id: number;

symbol: Symbol;

constructor(checker: TypeChecker, flags: TypeFlags) {

this.checker = checker;

this.flags = flags;

}

getFlags(): TypeFlags {

return this.flags;

}

getSymbol(): Symbol | undefined {

return this.symbol;

}

getProperties(): Symbol[] {

return this.checker.getPropertiesOfType(this);

}

getProperty(propertyName: string): Symbol | undefined {

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

}

getApparentProperties(): Symbol[] {

return this.checker.getAugmentedPropertiesOfType(this);

}

getCallSignatures(): ReadonlyArray<Signature> {

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

}

getConstructSignatures(): ReadonlyArray<Signature> {

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

}

getStringIndexType(): Type | undefined {

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

}

getNumberIndexType(): Type | undefined {

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

}

getBaseTypes(): BaseType[] | undefined {

return this.isClassOrInterface() ? this.checker.getBaseTypes(this) : undefined;

}

getNonNullableType(): Type {

return this.checker.getNonNullableType(this);

}

getConstraint(): Type | undefined {

return this.checker.getBaseConstraintOfType(this);

}

getDefault(): Type | undefined {

return this.checker.getDefaultFromTypeParameter(this);

}

isUnion(): this is UnionType {

return !!(this.flags & TypeFlags.Union);

}

isIntersection(): this is IntersectionType {

return !!(this.flags & TypeFlags.Intersection);

}

isUnionOrIntersection(): this is UnionOrIntersectionType {

return !!(this.flags & TypeFlags.UnionOrIntersection);

}

isLiteral(): this is LiteralType {

return !!(this.flags & TypeFlags.StringOrNumberLiteral);

}

isStringLiteral(): this is StringLiteralType {

return !!(this.flags & TypeFlags.StringLiteral);

}

isNumberLiteral(): this is NumberLiteralType {

return !!(this.flags & TypeFlags.NumberLiteral);

}

isTypeParameter(): this is TypeParameter {

return !!(this.flags & TypeFlags.TypeParameter);

}

isClassOrInterface(): this is InterfaceType {

return !!(getObjectFlags(this) & ObjectFlags.ClassOrInterface);

}

isClass(): this is InterfaceType {

return !!(getObjectFlags(this) & ObjectFlags.Class);

}

}

class SignatureObject implements Signature {

checker: TypeChecker;

declaration: SignatureDeclaration;

typeParameters?: TypeParameter[];

parameters: Symbol[];

thisParameter: Symbol;

resolvedReturnType: Type;

resolvedTypePredicate: TypePredicate | undefined;

minTypeArgumentCount: number;

minArgumentCount: number;

hasRestParameter: boolean;

hasLiteralTypes: boolean;

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

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

documentationComment?: SymbolDisplayPart[];

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

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

jsDocTags?: JSDocTagInfo[];

constructor(checker: TypeChecker) {

this.checker = checker;

}

getDeclaration(): SignatureDeclaration {

return this.declaration;

}

getTypeParameters(): TypeParameter[] | undefined {

return this.typeParameters;

}

getParameters(): Symbol[] {

return this.parameters;

}

getReturnType(): Type {

return this.checker.getReturnTypeOfSignature(this);

}

getDocumentationComment(): SymbolDisplayPart[] {

return this.documentationComment || (this.documentationComment = getDocumentationComment(singleElementArray(this.declaration), this.checker));

}

getJsDocTags(): JSDocTagInfo[] {

if (this.jsDocTags === undefined) {

this.jsDocTags = this.declaration ? JsDoc.getJsDocTagsFromDeclarations([this.declaration]) : [];

}

return this.jsDocTags;

}

}

/**

* Returns whether or not the given node has a JSDoc "inheritDoc" tag on it.

* @param node the Node in question.

* @returns `true` if `node` has a JSDoc "inheritDoc" tag on it, otherwise `false`.

*/

function hasJSDocInheritDocTag(node: Node) {

return getJSDocTags(node).some(tag => tag.tagName.text === "inheritDoc");

}

function getDocumentationComment(declarations: ReadonlyArray<Declaration> | undefined, checker: TypeChecker | undefined): SymbolDisplayPart[] {

if (!declarations) return emptyArray;

let doc = JsDoc.getJsDocCommentsFromDeclarations(declarations);

if (doc.length === 0 || declarations.some(hasJSDocInheritDocTag)) {

for (const declaration of declarations) {

const inheritedDocs = findInheritedJSDocComments(declaration, declaration.symbol.name, checker!); // TODO: GH#18217

// TODO: GH#16312 Return a ReadonlyArray, avoid copying inheritedDocs

if (inheritedDocs) doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(lineBreakPart(), doc);

}

}

return doc;

}

/**

* Attempts to find JSDoc comments for possibly-inherited properties. Checks superclasses then traverses

* implemented interfaces until a symbol is found with the same name and with documentation.

* @param declaration The possibly-inherited declaration to find comments for.

* @param propertyName The name of the possibly-inherited property.

* @param typeChecker A TypeChecker, used to find inherited properties.

* @returns A filled array of documentation comments if any were found, otherwise an empty array.

*/

function findInheritedJSDocComments(declaration: Declaration, propertyName: string, typeChecker: TypeChecker): ReadonlyArray<SymbolDisplayPart> | undefined {

return firstDefined(declaration.parent ? getAllSuperTypeNodes(declaration.parent) : emptyArray, superTypeNode => {

const superType = typeChecker.getTypeAtLocation(superTypeNode);

const baseProperty = superType && typeChecker.getPropertyOfType(superType, propertyName);

const inheritedDocs = baseProperty && baseProperty.getDocumentationComment(typeChecker);

return inheritedDocs && inheritedDocs.length ? inheritedDocs : undefined;

});

}

class SourceFileObject extends NodeObject implements SourceFile {

public kind: SyntaxKind.SourceFile;

public _declarationBrand: any;

public fileName: string;

public path: Path;

public resolvedPath: Path;

public text: string;

public scriptSnapshot: IScriptSnapshot;

public lineMap: ReadonlyArray<number>;

public statements: NodeArray<Statement>;

public endOfFileToken: Token<SyntaxKind.EndOfFileToken>;

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

public moduleName: string;

public referencedFiles: FileReference[];

public typeReferenceDirectives: FileReference[];

public libReferenceDirectives: FileReference[];

public syntacticDiagnostics: DiagnosticWithLocation[];

public parseDiagnostics: DiagnosticWithLocation[];

public bindDiagnostics: DiagnosticWithLocation[];

public bindSuggestionDiagnostics?: DiagnosticWithLocation[];

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

public resolvedModules: Map<ResolvedModuleFull>;

public resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective>;

public imports: ReadonlyArray<StringLiteralLike>;

public moduleAugmentations: StringLiteral[];

private namedDeclarations: Map<Declaration[]>;

public ambientModuleNames: string[];

public checkJsDirective: CheckJsDirective | undefined;

public possiblyContainDynamicImport: boolean;

public pragmas: PragmaMap;

public localJsxFactory: EntityName;

public localJsxNamespace: __String;

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 getLineAndCharacterOfPosition(this, position);

}

public getLineStarts(): ReadonlyArray<number> {

return getLineStarts(this);

}

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

return getPositionOfLineAndCharacter(this, line, character);

}

public getLineEndOfPosition(pos: number): number {

const { line } = this.getLineAndCharacterOfPosition(pos);

const lineStarts = this.getLineStarts();

let lastCharPos: number | undefined;

if (line + 1 >= lineStarts.length) {

lastCharPos = this.getEnd();

}

if (!lastCharPos) {

lastCharPos = lineStarts[line + 1] - 1;

}

const fullText = this.getFullText();

// if the new line is "\r\n", we should return the last non-new-line-character position

return fullText[lastCharPos] === "\n" && fullText[lastCharPos - 1] === "\r" ? lastCharPos - 1 : lastCharPos;

}

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

if (!this.namedDeclarations) {

this.namedDeclarations = this.computeNamedDeclarations();

}

return this.namedDeclarations;

}

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

const result = createMultiMap<Declaration>();

this.forEachChild(visit);

return result;

function addDeclaration(declaration: Declaration) {

const name = getDeclarationName(declaration);

if (name) {

result.add(name, declaration);

}

}

function getDeclarations(name: string) {

let declarations = result.get(name);

if (!declarations) {

result.set(name, declarations = []);

}

return declarations;

}

function getDeclarationName(declaration: Declaration) {

const name = getNonAssignedNameOfDeclaration(declaration);

return name && (isComputedPropertyName(name) && isPropertyAccessExpression(name.expression) ? name.expression.name.text

: isPropertyName(name) ? getNameFromPropertyName(name) : 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.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 (!hasModifier(node, ModifierFlags.ParameterPropertyModifier)) {

break;

}

// falls through

case SyntaxKind.VariableDeclaration:

case SyntaxKind.BindingElement: {

const decl = <VariableDeclaration>node;

if (isBindingPattern(decl.name)) {

forEachChild(decl.name, visit);

break;

}

if (decl.initializer) {

visit(decl.initializer);

}

}

// falls through

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:

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

if (importClause) {

// Handle default import case e.g.:

// import d from "mod";

if (importClause.name) {

addDeclaration(importClause.name);

}

// 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(importClause.namedBindings);

}

else {

forEach(importClause.namedBindings.elements, visit);

}

}

}

break;

case SyntaxKind.BinaryExpression:

if (getSpecialPropertyAssignmentKind(node as BinaryExpression) !== SpecialPropertyAssignmentKind.None) {

addDeclaration(node as BinaryExpression);

}

// falls through

default:

forEachChild(node, visit);

}

}

}

}

class SourceMapSourceObject implements SourceMapSource {

lineMap: number[];

constructor(public fileName: string, public text: string, public skipTrivia?: (pos: number) => number) { }

public getLineAndCharacterOfPosition(pos: number): LineAndCharacter {

return getLineAndCharacterOfPosition(this, pos);

}

}

function getServicesObjectAllocator(): ObjectAllocator {

return {

getNodeConstructor: () => NodeObject,

getTokenConstructor: () => TokenObject,

getIdentifierConstructor: () => IdentifierObject,

getSourceFileConstructor: () => SourceFileObject,

getSymbolConstructor: () => SymbolObject,

getTypeConstructor: () => TypeObject,

getSignatureConstructor: () => SignatureObject,

getSourceMapSourceConstructor: () => SourceMapSourceObject,

};

}

/// Language Service

// Information about a specific host file.

interface HostFileInformation {

hostFileName: string;

version: string;

scriptSnapshot: IScriptSnapshot;

scriptKind: ScriptKind;

}

/* @internal */

export interface DisplayPartsSymbolWriter extends EmitTextWriter {

displayParts(): SymbolDisplayPart[];

}

/* @internal */

export function toEditorSettings(options: FormatCodeOptions | FormatCodeSettings): FormatCodeSettings;

export function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;

export function toEditorSettings(optionsAsMap: MapLike<any>): MapLike<any> {

let allPropertiesAreCamelCased = true;

for (const key in optionsAsMap) {

if (hasProperty(optionsAsMap, key) && !isCamelCase(key)) {

allPropertiesAreCamelCased = false;

break;

}

}

if (allPropertiesAreCamelCased) {

return optionsAsMap;

}

const settings: MapLike<any> = {};

for (const key in optionsAsMap) {

if (hasProperty(optionsAsMap, key)) {

const newKey = isCamelCase(key) ? key : key.charAt(0).toLowerCase() + key.substr(1);

settings[newKey] = optionsAsMap[key];

}

}

return settings;

}

function isCamelCase(s: string) {

return !s.length || s.charAt(0) === s.charAt(0).toLowerCase();

}

export function displayPartsToString(displayParts: SymbolDisplayPart[] | undefined) {

if (displayParts) {

return map(displayParts, displayPart => displayPart.text).join("");

}

return "";

}

export function getDefaultCompilerOptions(): CompilerOptions {

// Always default to "ScriptTarget.ES5" for the language service

return {

target: ScriptTarget.ES5,

jsx: JsxEmit.Preserve

};

}

export function getSupportedCodeFixes() {

return codefix.getSupportedErrorCodes();

}

// Either it will be file name if host doesnt have file or it will be the host's file information

type CachedHostFileInformation = HostFileInformation | string;

// Cache host information about script Should be refreshed

// at each language service public entry point, since we don't know when

// the set of scripts handled by the host changes.

class HostCache {

private fileNameToEntry: Map<CachedHostFileInformation>;

private _compilationSettings: CompilerOptions;

private currentDirectory: string;

constructor(private host: LanguageServiceHost, getCanonicalFileName: GetCanonicalFileName) {

// script id => script index

this.currentDirectory = host.getCurrentDirectory();

this.fileNameToEntry = createMap<CachedHostFileInformation>();

// Initialize the list with the root file names

const rootFileNames = host.getScriptFileNames();

for (const fileName of rootFileNames) {

this.createEntry(fileName, toPath(fileName, this.currentDirectory, getCanonicalFileName));

}

// store the compilation settings

this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions();

}

public compilationSettings() {

return this._compilationSettings;

}

public getProjectReferences(): ReadonlyArray<ProjectReference> | undefined {

return this.host.getProjectReferences && this.host.getProjectReferences();

}

private createEntry(fileName: string, path: Path) {

let entry: CachedHostFileInformation;

const scriptSnapshot = this.host.getScriptSnapshot(fileName);

if (scriptSnapshot) {

entry = {

hostFileName: fileName,

version: this.host.getScriptVersion(fileName),

scriptSnapshot,

scriptKind: getScriptKind(fileName, this.host)

};

}

else {

entry = fileName;

}

this.fileNameToEntry.set(path, entry);

return entry;

}

public getEntryByPath(path: Path): CachedHostFileInformation | undefined {

return this.fileNameToEntry.get(path);

}

public getHostFileInformation(path: Path): HostFileInformation | undefined {

const entry = this.fileNameToEntry.get(path);

return !isString(entry) ? entry : undefined;

}

public getOrCreateEntryByPath(fileName: string, path: Path): HostFileInformation {

const info = this.getEntryByPath(path) || this.createEntry(fileName, path);

return isString(info) ? undefined! : info; // TODO: GH#18217

}

public getRootFileNames(): string[] {

const names: string[] = [];

this.fileNameToEntry.forEach(entry => {

if (isString(entry)) {

names.push(entry);

}

else {

if (entry.scriptKind !== ScriptKind.JSON) {

names.push(entry.hostFileName);

}

}

});

return names;

}

public getVersion(path: Path): string {

const file = this.getHostFileInformation(path);

return (file && file.version)!; // TODO: GH#18217

}

public getScriptSnapshot(path: Path): IScriptSnapshot {

const file = this.getHostFileInformation(path);

return (file && file.scriptSnapshot)!; // TODO: GH#18217

}

}

class SyntaxTreeCache {

// For our syntactic only features, we also keep a cache of the syntax tree for the

// currently edited file.

private currentFileName: string;

private currentFileVersion: string;

private currentFileScriptSnapshot: IScriptSnapshot;

private currentSourceFile: SourceFile;

constructor(private host: LanguageServiceHost) {

}

public getCurrentSourceFile(fileName: string): SourceFile {

const scriptSnapshot = this.host.getScriptSnapshot(fileName);

if (!scriptSnapshot) {

// The host does not know about this file.

throw new Error("Could not find file: '" + fileName + "'.");

}

const scriptKind = getScriptKind(fileName, this.host);

const version = this.host.getScriptVersion(fileName);

let sourceFile: SourceFile | undefined;

if (this.currentFileName !== fileName) {

// This is a new file, just parse it

sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, ScriptTarget.Latest, version, /*setNodeParents*/ true, scriptKind);

}

else if (this.currentFileVersion !== version) {

// This is the same file, just a newer version. Incrementally parse the file.

const editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot);

sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange);

}

if (sourceFile) {

// All done, ensure state is up to date

this.currentFileVersion = version;

this.currentFileName = fileName;

this.currentFileScriptSnapshot = scriptSnapshot;

this.currentSourceFile = sourceFile;

}

return this.currentSourceFile;

}

}

function setSourceFileFields(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string) {

sourceFile.version = version;

sourceFile.scriptSnapshot = scriptSnapshot;