fileNames: string[]; // The file names that belong to the same project.

projectRootPath: string; // The path to the project root directory

safeListPath: string; // The path used to retrieve the safe list

packageNameToTypingLocation: Map<JsTyping.CachedTyping>; // The map of package names to their cached typing locations and installed versions

typeAcquisition: TypeAcquisition; // Used to customize the type acquisition process

compilerOptions: CompilerOptions; // Used as a source for typing inference

unresolvedImports: ReadonlyArray<string>; // List of unresolved module ids from imports

typesRegistry: ReadonlyMap<MapLike<string>>; // The map of available typings in npm to maps of TS versions to their latest supported versions

/** 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: ScriptSnapshotShim): string | undefined;

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

dispose?(): void;

log(s: string): void;

trace(s: string): void;

error(s: string): void;

getCompilationSettings(): string;

/** Returns a JSON-encoded value of the type: string[] */

getScriptFileNames(): string;

getScriptKind?(fileName: string): ScriptKind;

getScriptVersion(fileName: string): string;

getScriptSnapshot(fileName: string): ScriptSnapshotShim;

getLocalizedDiagnosticMessages(): string;

getCancellationToken(): HostCancellationToken;

getCurrentDirectory(): string;

getDirectories(path: string): string;

getDefaultLibFileName(options: string): string;

getNewLine?(): string;

getProjectVersion?(): string;

useCaseSensitiveFileNames?(): boolean;

getTypeRootsVersion?(): number;

readDirectory(rootDir: string, extension: string, basePaths?: string, excludeEx?: string, includeFileEx?: string, includeDirEx?: string, depth?: number): string;

readFile(path: string, encoding?: string): string | undefined;

fileExists(path: string): boolean;

getModuleResolutionsForFile?(fileName: string): string;

getTypeReferenceDirectiveResolutionsForFile?(fileName: string): string;

directoryExists(directoryName: string): boolean;

directoryExists(directoryName: string): boolean;

fileExists(fileName: string): boolean;

getCurrentDirectory(): string;

getDirectories(path: string): string;

/**

readDirectory(rootDir: string, extension: string, basePaths?: string, excludeEx?: string, includeFileEx?: string, includeDirEx?: string, depth?: number): string;

/**

readFile(fileName: string): string | undefined;

realpath?(path: string): string;

trace(s: string): void;

useCaseSensitiveFileNames?(): boolean;

path: string;

position: number;

length: number;

languageService: LanguageService;

dispose(_dummy: {}): void;

refresh(throwOnError: boolean): void;

cleanupSemanticCache(): void;

getSyntacticDiagnostics(fileName: string): string;

getSemanticDiagnostics(fileName: string): string;

getSuggestionDiagnostics(fileName: string): string;

getCompilerOptionsDiagnostics(): string;

getSyntacticClassifications(fileName: string, start: number, length: number): string;

getSemanticClassifications(fileName: string, start: number, length: number): string;

getEncodedSyntacticClassifications(fileName: string, start: number, length: number): string;

getEncodedSemanticClassifications(fileName: string, start: number, length: number): string;

getCompletionsAtPosition(fileName: string, position: number, preferences: UserPreferences | undefined): string;

getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: string/*Services.FormatCodeOptions*/ | undefined, source: string | undefined, preferences: UserPreferences | undefined): string;

getQuickInfoAtPosition(fileName: string, position: number): string;

getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): string;

getBreakpointStatementAtPosition(fileName: string, position: number): string;

getSignatureHelpItems(fileName: string, position: number, options: SignatureHelpItemsOptions | undefined): string;

/**

getRenameInfo(fileName: string, position: number): string;

/**

findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): string;

/**

getDefinitionAtPosition(fileName: string, position: number): string;

getDefinitionAndBoundSpan(fileName: string, position: number): string;

/**

getTypeDefinitionAtPosition(fileName: string, position: number): string;

/**

getImplementationAtPosition(fileName: string, position: number): string;

/**

getReferencesAtPosition(fileName: string, position: number): string;

/**

findReferences(fileName: string, position: number): string;

/**

getOccurrencesAtPosition(fileName: string, position: number): string;

/**

getDocumentHighlights(fileName: string, position: number, filesToSearch: string): string;

/**

getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string): string;

/**

getNavigationBarItems(fileName: string): string;

/** Returns a JSON-encoded value of the type ts.NavigationTree. */

getNavigationTree(fileName: string): string;

/**

getOutliningSpans(fileName: string): string;

getTodoComments(fileName: string, todoCommentDescriptors: string): string;

getBraceMatchingAtPosition(fileName: string, position: number): string;

getIndentationAtPosition(fileName: string, position: number, options: string/*Services.EditorOptions*/): string;

getFormattingEditsForRange(fileName: string, start: number, end: number, options: string/*Services.FormatCodeOptions*/): string;

getFormattingEditsForDocument(fileName: string, options: string/*Services.FormatCodeOptions*/): string;

getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: string/*Services.FormatCodeOptions*/): string;

/**

getDocCommentTemplateAtPosition(fileName: string, position: number): string;

/**

isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): string;

/**

getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): string;

getEmitOutput(fileName: string): string;

getEmitOutputObject(fileName: string): EmitOutput;

getAutomaticTypeDirectiveNames(compilerOptionsJson: string): string;

getPreProcessedFileInfo(fileName: string, sourceText: IScriptSnapshot): string;

getTSConfigFileInfo(fileName: string, sourceText: IScriptSnapshot): string;

getDefaultCompilationSettings(): string;

discoverTypings(discoverTypingsJson: string): string;

if (logger) {

logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message);

}

constructor(private scriptSnapshotShim: ScriptSnapshotShim) {

}

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

return this.scriptSnapshotShim.getText(start, end);

}

public getLength(): number {

return this.scriptSnapshotShim.getLength();

}

public getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined {

const oldSnapshotShim = <ScriptSnapshotShimAdapter>oldSnapshot;

const encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim);

if (encoded === null) {

return null!; // TODO: GH#18217

}

const decoded: { span: { start: number; length: number; }; newLength: number; } = JSON.parse(encoded!); // TODO: GH#18217

return createTextChangeRange(

createTextSpan(decoded.span.start, decoded.span.length), decoded.newLength);

}

public dispose(): void {

// if scriptSnapshotShim is a COM object then property check becomes method call with no arguments

// 'in' does not have this effect

if ("dispose" in this.scriptSnapshotShim) {

this.scriptSnapshotShim.dispose!(); // TODO: GH#18217 Can we just use `if (this.scriptSnapshotShim.dispose)`?

}

}

private files: string[];

private loggingEnabled = false;

private tracingEnabled = false;

public resolveModuleNames: (moduleName: string[], containingFile: string) => ResolvedModuleFull[];

public resolveTypeReferenceDirectives: (typeDirectiveNames: string[], containingFile: string) => ResolvedTypeReferenceDirective[];

public directoryExists: (directoryName: string) => boolean;

constructor(private shimHost: LanguageServiceShimHost) {

// if shimHost is a COM object then property check will become method call with no arguments.

// 'in' does not have this effect.

if ("getModuleResolutionsForFile" in this.shimHost) {

this.resolveModuleNames = (moduleNames: string[], containingFile: string): ResolvedModuleFull[] => {

const resolutionsInFile = <MapLike<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile!(containingFile)); // TODO: GH#18217

return map(moduleNames, name => {

const result = getProperty(resolutionsInFile, name);

return result ? { resolvedFileName: result, extension: extensionFromPath(result), isExternalLibraryImport: false } : undefined!; // TODO: GH#18217

});

};

}

if ("directoryExists" in this.shimHost) {

this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);

}

if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {

this.resolveTypeReferenceDirectives = (typeDirectiveNames: string[], containingFile: string) => {

const typeDirectivesForFile = <MapLike<ResolvedTypeReferenceDirective>>JSON.parse(this.shimHost.getTypeReferenceDirectiveResolutionsForFile!(containingFile)); // TODO: GH#18217

return map(typeDirectiveNames, name => getProperty(typeDirectivesForFile, name)!); // TODO: GH#18217

};

}

}

public log(s: string): void {

if (this.loggingEnabled) {

this.shimHost.log(s);

}

}

public trace(s: string): void {

if (this.tracingEnabled) {

this.shimHost.trace(s);

}

}

public error(s: string): void {

this.shimHost.error(s);

}

public getProjectVersion(): string {

if (!this.shimHost.getProjectVersion) {

// shimmed host does not support getProjectVersion

return undefined!; // TODO: GH#18217

}

return this.shimHost.getProjectVersion();

}

public getTypeRootsVersion(): number {

if (!this.shimHost.getTypeRootsVersion) {

return 0;

}

return this.shimHost.getTypeRootsVersion();

}

public useCaseSensitiveFileNames(): boolean {

return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;

}

public getCompilationSettings(): CompilerOptions {

const settingsJson = this.shimHost.getCompilationSettings();

if (settingsJson === null || settingsJson === "") {

throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");

}

const compilerOptions = <CompilerOptions>JSON.parse(settingsJson);

// permit language service to handle all files (filtering should be performed on the host side)

compilerOptions.allowNonTsExtensions = true;

return compilerOptions;

}

public getScriptFileNames(): string[] {

const encoded = this.shimHost.getScriptFileNames();

return this.files = JSON.parse(encoded);

}

public getScriptSnapshot(fileName: string): IScriptSnapshot | undefined {

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

return scriptSnapshot && new ScriptSnapshotShimAdapter(scriptSnapshot);

}

public getScriptKind(fileName: string): ScriptKind {

if ("getScriptKind" in this.shimHost) {

return this.shimHost.getScriptKind!(fileName); // TODO: GH#18217

}

else {

return ScriptKind.Unknown;

}

}

public getScriptVersion(fileName: string): string {

return this.shimHost.getScriptVersion(fileName);

}

public getLocalizedDiagnosticMessages() {

const diagnosticMessagesJson = this.shimHost.getLocalizedDiagnosticMessages();

if (diagnosticMessagesJson === null || diagnosticMessagesJson === "") {

return null;

}

try {

return JSON.parse(diagnosticMessagesJson);

}

catch (e) {

this.log(e.description || "diagnosticMessages.generated.json has invalid JSON format");

return null;

}

}

public getCancellationToken(): HostCancellationToken {

const hostCancellationToken = this.shimHost.getCancellationToken();

return new ThrottledCancellationToken(hostCancellationToken);

}

public getCurrentDirectory(): string {

return this.shimHost.getCurrentDirectory();

}

public getDirectories(path: string): string[] {

return JSON.parse(this.shimHost.getDirectories(path));

}

public getDefaultLibFileName(options: CompilerOptions): string {

return this.shimHost.getDefaultLibFileName(JSON.stringify(options));

}

public readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: string[], include?: string[], depth?: number): string[] {

const pattern = getFileMatcherPatterns(path, exclude, include,

this.shimHost.useCaseSensitiveFileNames!(), this.shimHost.getCurrentDirectory()); // TODO: GH#18217

return JSON.parse(this.shimHost.readDirectory(

path,

JSON.stringify(extensions),

JSON.stringify(pattern.basePaths),

pattern.excludePattern,

pattern.includeFilePattern,

pattern.includeDirectoryPattern,

depth

));

}

public readFile(path: string, encoding?: string): string | undefined {

return this.shimHost.readFile(path, encoding);

}

public fileExists(path: string): boolean {

return this.shimHost.fileExists(path);

}

public directoryExists: (directoryName: string) => boolean;

public realpath: (path: string) => string;

public useCaseSensitiveFileNames: boolean;

constructor(private shimHost: CoreServicesShimHost) {

this.useCaseSensitiveFileNames = this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;

if ("directoryExists" in this.shimHost) {

this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);

}

if ("realpath" in this.shimHost) {

this.realpath = path => this.shimHost.realpath!(path); // TODO: GH#18217

}

}

public readDirectory(rootDir: string, extensions: ReadonlyArray<string>, exclude: ReadonlyArray<string>, include: ReadonlyArray<string>, depth?: number): string[] {

const pattern = getFileMatcherPatterns(rootDir, exclude, include,

this.shimHost.useCaseSensitiveFileNames!(), this.shimHost.getCurrentDirectory()); // TODO: GH#18217

return JSON.parse(this.shimHost.readDirectory(

rootDir,

JSON.stringify(extensions),

JSON.stringify(pattern.basePaths),

pattern.excludePattern,

pattern.includeFilePattern,

pattern.includeDirectoryPattern,

depth

));

}

public fileExists(fileName: string): boolean {

return this.shimHost.fileExists(fileName);

}

public readFile(fileName: string): string | undefined {

return this.shimHost.readFile(fileName);

}

public getDirectories(path: string): string[] {

return JSON.parse(this.shimHost.getDirectories(path));

}

let start: number | undefined;

if (logPerformance) {

logger.log(actionDescription);

start = timestamp();

}

const result = action();

if (logPerformance) {

const end = timestamp();

logger.log(`${actionDescription} completed in ${end - start!} msec`);

if (isString(result)) {

let str = result;

if (str.length > 128) {

str = str.substring(0, 128) + "...";

}

logger.log(` result.length=${str.length}, result='${JSON.stringify(str)}'`);

}

}

return result;

try {

const result = simpleForwardCall(logger, actionDescription, action, logPerformance);

return returnJson ? JSON.stringify({ result }) : result as T;

}

catch (err) {

if (err instanceof OperationCanceledException) {

return JSON.stringify({ canceled: true });

}

logInternalError(logger, err);

err.description = actionDescription;

return JSON.stringify({ error: err });

}

constructor(private factory: ShimFactory) {

factory.registerShim(this);

}

public dispose(_dummy: {}): void {

this.factory.unregisterShim(this);

}

message: string;

start: number;

length: number;

category: string;

code: number;

reportsUnnecessary?: {};

return {

message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),

start: diagnostic.start!, // TODO: GH#18217

length: diagnostic.length!, // TODO: GH#18217

category: diagnosticCategoryName(diagnostic),

code: diagnostic.code,

reportsUnnecessary: diagnostic.reportsUnnecessary,

};

private logger: Logger;

private logPerformance = false;

constructor(factory: ShimFactory,

private host: LanguageServiceShimHost,

public languageService: LanguageService) {

super(factory);

this.logger = this.host;

}

public forwardJSONCall(actionDescription: string, action: () => {} | null | undefined): string {

return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance);

}

/// DISPOSE

/**

public dispose(dummy: {}): void {

this.logger.log("dispose()");

this.languageService.dispose();

this.languageService = null!;

// force a GC

if (debugObjectHost && debugObjectHost.CollectGarbage) {

debugObjectHost.CollectGarbage();

this.logger.log("CollectGarbage()");

}

this.logger = null!;

super.dispose(dummy);

}

/// REFRESH

/**

public refresh(throwOnError: boolean): void {

this.forwardJSONCall(

`refresh(${throwOnError})`,

() => null

);

}

public cleanupSemanticCache(): void {

this.forwardJSONCall(

"cleanupSemanticCache()",

() => {

this.languageService.cleanupSemanticCache();

return null;

});

}

private realizeDiagnostics(diagnostics: ReadonlyArray<Diagnostic>): { message: string; start: number; length: number; category: string; }[] {

const newLine = getNewLineOrDefaultFromHost(this.host);

return realizeDiagnostics(diagnostics, newLine);

}

public getSyntacticClassifications(fileName: string, start: number, length: number): string {

return this.forwardJSONCall(

`getSyntacticClassifications('${fileName}', ${start}, ${length})`,

() => this.languageService.getSyntacticClassifications(fileName, createTextSpan(start, length))

);

}

public getSemanticClassifications(fileName: string, start: number, length: number): string {

return this.forwardJSONCall(

`getSemanticClassifications('${fileName}', ${start}, ${length})`,

() => this.languageService.getSemanticClassifications(fileName, createTextSpan(start, length))

);

}

public getEncodedSyntacticClassifications(fileName: string, start: number, length: number): string {

return this.forwardJSONCall(

`getEncodedSyntacticClassifications('${fileName}', ${start}, ${length})`,

// directly serialize the spans out to a string. This is much faster to decode

// on the managed side versus a full JSON array.

() => convertClassifications(this.languageService.getEncodedSyntacticClassifications(fileName, createTextSpan(start, length)))

);

}

public getEncodedSemanticClassifications(fileName: string, start: number, length: number): string {

return this.forwardJSONCall(

`getEncodedSemanticClassifications('${fileName}', ${start}, ${length})`,

// directly serialize the spans out to a string. This is much faster to decode

// on the managed side versus a full JSON array.

() => convertClassifications(this.languageService.getEncodedSemanticClassifications(fileName, createTextSpan(start, length)))

);

}

public getSyntacticDiagnostics(fileName: string): string {

return this.forwardJSONCall(

`getSyntacticDiagnostics('${fileName}')`,

() => {

const diagnostics = this.languageService.getSyntacticDiagnostics(fileName);

return this.realizeDiagnostics(diagnostics);

});

}

public getSemanticDiagnostics(fileName: string): string {

return this.forwardJSONCall(

`getSemanticDiagnostics('${fileName}')`,

() => {

const diagnostics = this.languageService.getSemanticDiagnostics(fileName);

return this.realizeDiagnostics(diagnostics);

});

}

public getSuggestionDiagnostics(fileName: string): string {

return this.forwardJSONCall(`getSuggestionDiagnostics('${fileName}')`, () => this.realizeDiagnostics(this.languageService.getSuggestionDiagnostics(fileName)));

}

public getCompilerOptionsDiagnostics(): string {

return this.forwardJSONCall(

"getCompilerOptionsDiagnostics()",

() => {

const diagnostics = this.languageService.getCompilerOptionsDiagnostics();

return this.realizeDiagnostics(diagnostics);

});

}

/// QUICKINFO

/**

public getQuickInfoAtPosition(fileName: string, position: number): string {

return this.forwardJSONCall(

`getQuickInfoAtPosition('${fileName}', ${position})`,

() => this.languageService.getQuickInfoAtPosition(fileName, position)

);

}

/// NAMEORDOTTEDNAMESPAN

/**

public getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): string {

return this.forwardJSONCall(

`getNameOrDottedNameSpan('${fileName}', ${startPos}, ${endPos})`,

() => this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos)

);

}

/**

public getBreakpointStatementAtPosition(fileName: string, position: number): string {

return this.forwardJSONCall(

`getBreakpointStatementAtPosition('${fileName}', ${position})`,

() => this.languageService.getBreakpointStatementAtPosition(fileName, position)

);

}

/// SIGNATUREHELP

public getSignatureHelpItems(fileName: string, position: number, options: SignatureHelpItemsOptions | undefined): string {

return this.forwardJSONCall(

`getSignatureHelpItems('${fileName}', ${position})`,

() => this.languageService.getSignatureHelpItems(fileName, position, options)

);

}

/// GOTO DEFINITION

/**

public getDefinitionAtPosition(fileName: string, position: number): string {

return this.forwardJSONCall(

`getDefinitionAtPosition('${fileName}', ${position})`,

() => this.languageService.getDefinitionAtPosition(fileName, position)

);

}

/**

public getDefinitionAndBoundSpan(fileName: string, position: number): string {

return this.forwardJSONCall(

`getDefinitionAndBoundSpan('${fileName}', ${position})`,

() => this.languageService.getDefinitionAndBoundSpan(fileName, position)

);

}

/// GOTO Type

/**

public getTypeDefinitionAtPosition(fileName: string, position: number): string {

return this.forwardJSONCall(

`getTypeDefinitionAtPosition('${fileName}', ${position})`,

() => this.languageService.getTypeDefinitionAtPosition(fileName, position)

);

}

/// GOTO Implementation

/**

public getImplementationAtPosition(fileName: string, position: number): string {