switch (process.platform) {

case "win32": {

const basePath = process.env.LOCALAPPDATA ||

process.env.APPDATA ||

(os.homedir && os.homedir()) ||

process.env.USERPROFILE ||

(process.env.HOMEDRIVE && process.env.HOMEPATH && normalizeSlashes(process.env.HOMEDRIVE + process.env.HOMEPATH)) ||

os.tmpdir();

return combinePaths(combinePaths(normalizeSlashes(basePath), "Microsoft/TypeScript"), versionMajorMinor);

}

case "openbsd":

case "freebsd":

case "darwin":

case "linux":

case "android": {

const cacheLocation = getNonWindowsCacheLocation(process.platform === "darwin");

return combinePaths(combinePaths(cacheLocation, "typescript"), versionMajorMinor);

}

default:

Debug.fail(`unsupported platform '${process.platform}'`);

return;

}

if (process.env.XDG_CACHE_HOME) {

return process.env.XDG_CACHE_HOME;

}

const usersDir = platformIsDarwin ? "Users" : "home";

const homePath = (os.homedir && os.homedir()) ||

process.env.HOME ||

((process.env.LOGNAME || process.env.USER) && `/${usersDir}/${process.env.LOGNAME || process.env.USER}`) ||

os.tmpdir();

const cacheFolder = platformIsDarwin

? "Library/Caches"

: ".cache";

return combinePaths(normalizeSlashes(homePath), cacheFolder);

send(message: any, sendHandle?: any): void;

on(message: "message" | "exit", f: (m: any) => void): void;

kill(): void;

pid: number;

input: NodeJS.ReadableStream;

output?: NodeJS.WritableStream;

terminal?: boolean;

historySize?: number;

isFile(): boolean;

isDirectory(): boolean;

isBlockDevice(): boolean;

isCharacterDevice(): boolean;

isSymbolicLink(): boolean;

isFIFO(): boolean;

isSocket(): boolean;

dev: number;

ino: number;

mode: number;

nlink: number;

uid: number;

gid: number;

rdev: number;

size: number;

blksize: number;

blocks: number;

atime: Date;

mtime: Date;

ctime: Date;

birthtime: Date;

private fd = -1;

private seq = 0;

private inGroup = false;

private firstInGroup = true;

constructor(private readonly logFilename: string,

private readonly traceToConsole: boolean,

private readonly level: LogLevel) {

if (this.logFilename) {

try {

this.fd = fs.openSync(this.logFilename, "w");

}

catch (_) {

// swallow the error and keep logging disabled if file cannot be opened

}

}

}

static padStringRight(str: string, padding: string) {

return (str + padding).slice(0, padding.length);

}

close() {

if (this.fd >= 0) {

fs.close(this.fd, noop);

}

}

getLogFileName() {

return this.logFilename;

}

perftrc(s: string) {

this.msg(s, Msg.Perf);

}

info(s: string) {

this.msg(s, Msg.Info);

}

err(s: string) {

this.msg(s, Msg.Err);

}

startGroup() {

this.inGroup = true;

this.firstInGroup = true;

}

endGroup() {

this.inGroup = false;

}

loggingEnabled() {

return !!this.logFilename || this.traceToConsole;

}

hasLevel(level: LogLevel) {

return this.loggingEnabled() && this.level >= level;

}

msg(s: string, type: Msg = Msg.Err) {

if (!this.canWrite) return;

s = `[${nowString()}] ${s}\n`;

if (!this.inGroup || this.firstInGroup) {

const prefix = Logger.padStringRight(type + " " + this.seq.toString(), " ");

s = prefix + s;

}

this.write(s);

if (!this.inGroup) {

this.seq++;

}

}

private get canWrite() {

return this.fd >= 0 || this.traceToConsole;

}

private write(s: string) {

if (this.fd >= 0) {

const buf = new Buffer(s);

// tslint:disable-next-line no-null-keyword

fs.writeSync(this.fd, buf, 0, buf.length, /*position*/ null);

}

if (this.traceToConsole) {

console.warn(s);

}

}

private installer: NodeChildProcess;

private projectService: ProjectService;

private activeRequestCount = 0;

private requestQueue: QueuedOperation[] = [];

private requestMap = createMap<QueuedOperation>(); // Maps operation ID to newest requestQueue entry with that ID

/** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */

private requestedRegistry: boolean;

private typesRegistryCache: Map<MapLike<string>> | undefined;

// This number is essentially arbitrary. Processing more than one typings request

// at a time makes sense, but having too many in the pipe results in a hang

// (see https://github.com/nodejs/node/issues/7657).

// It would be preferable to base our limit on the amount of space left in the

// buffer, but we have yet to find a way to retrieve that value.

private static readonly maxActiveRequestCount = 10;

private static readonly requestDelayMillis = 100;

private packageInstalledPromise: { resolve(value: ApplyCodeActionCommandResult): void, reject(reason: any): void };

constructor(

private readonly telemetryEnabled: boolean,

private readonly logger: Logger,

private readonly host: ServerHost,

readonly globalTypingsCacheLocation: string,

readonly typingSafeListLocation: string,

readonly typesMapLocation: string,

private readonly npmLocation: string | undefined,

private event: Event) {

}

isKnownTypesPackageName(name: string): boolean {

// We want to avoid looking this up in the registry as that is expensive. So first check that it's actually an NPM package.

const validationResult = JsTyping.validatePackageName(name);

if (validationResult !== JsTyping.PackageNameValidationResult.Ok) {

return false;

}

if (this.requestedRegistry) {

return !!this.typesRegistryCache && this.typesRegistryCache.has(name);

}

this.requestedRegistry = true;

this.send({ kind: "typesRegistry" });

return false;

}

installPackage(options: InstallPackageOptionsWithProject): Promise<ApplyCodeActionCommandResult> {

const rq: InstallPackageRequest = { kind: "installPackage", ...options };

this.send(rq);

Debug.assert(this.packageInstalledPromise === undefined);

return new Promise((resolve, reject) => {

this.packageInstalledPromise = { resolve, reject };

});

}

attach(projectService: ProjectService) {

this.projectService = projectService;

if (this.logger.hasLevel(LogLevel.requestTime)) {

this.logger.info("Binding...");

}

const args: string[] = [Arguments.GlobalCacheLocation, this.globalTypingsCacheLocation];

if (this.telemetryEnabled) {

args.push(Arguments.EnableTelemetry);

}

if (this.logger.loggingEnabled() && this.logger.getLogFileName()) {

args.push(Arguments.LogFile, combinePaths(getDirectoryPath(normalizeSlashes(this.logger.getLogFileName())), `ti-${process.pid}.log`));

}

if (this.typingSafeListLocation) {

args.push(Arguments.TypingSafeListLocation, this.typingSafeListLocation);

}

if (this.typesMapLocation) {

args.push(Arguments.TypesMapLocation, this.typesMapLocation);

}

if (this.npmLocation) {

args.push(Arguments.NpmLocation, this.npmLocation);

}

const execArgv: string[] = [];

for (const arg of process.execArgv) {

const match = /^--((?:debug|inspect)(?:-brk)?)(?:=(\d+))?$/.exec(arg);

if (match) {

// if port is specified - use port + 1

// otherwise pick a default port depending on if 'debug' or 'inspect' and use its value + 1

const currentPort = match[2] !== undefined

? +match[2]

: match[1].charAt(0) === "d" ? 5858 : 9229;

execArgv.push(`--${match[1]}=${currentPort + 1}`);

break;

}

}

this.installer = childProcess.fork(combinePaths(__dirname, "typingsInstaller.js"), args, { execArgv });

this.installer.on("message", m => this.handleMessage(m));

this.event({ pid: this.installer.pid }, "typingsInstallerPid");

process.on("exit", () => {

this.installer.kill();

});

}

onProjectClosed(p: Project): void {

this.send({ projectName: p.getProjectName(), kind: "closeProject" });

}

private send(rq: TypingInstallerRequestUnion): void {

this.installer.send(rq);

}

enqueueInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string>): void {

const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);

if (this.logger.hasLevel(LogLevel.verbose)) {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Scheduling throttled operation:${stringifyIndented(request)}`);

}

}

const operationId = project.getProjectName();

const operation = () => {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Sending request:${stringifyIndented(request)}`);

}

this.send(request);

};

const queuedRequest: QueuedOperation = { operationId, operation };

if (this.activeRequestCount < NodeTypingsInstaller.maxActiveRequestCount) {

this.scheduleRequest(queuedRequest);

}

else {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Deferring request for: ${operationId}`);

}

this.requestQueue.push(queuedRequest);

this.requestMap.set(operationId, queuedRequest);

}

}

private handleMessage(response: TypesRegistryResponse | PackageInstalledResponse | SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | InitializationFailedResponse) {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Received response:${stringifyIndented(response)}`);

}

switch (response.kind) {

case EventTypesRegistry:

this.typesRegistryCache = createMapFromTemplate(response.typesRegistry);

break;

case ActionPackageInstalled: {

const { success, message } = response;

if (success) {

this.packageInstalledPromise.resolve({ successMessage: message });

}

else {

this.packageInstalledPromise.reject(message);

}

this.packageInstalledPromise = undefined;

this.projectService.updateTypingsForProject(response);

// The behavior is the same as for setTypings, so send the same event.

this.event(response, "setTypings");

break;

}

case EventInitializationFailed:

{

const body: protocol.TypesInstallerInitializationFailedEventBody = {

message: response.message

};

const eventName: protocol.TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed";

this.event(body, eventName);

break;

}

case EventBeginInstallTypes:

{

const body: protocol.BeginInstallTypesEventBody = {

eventId: response.eventId,

packages: response.packagesToInstall,

};

const eventName: protocol.BeginInstallTypesEventName = "beginInstallTypes";

this.event(body, eventName);

break;

}

case EventEndInstallTypes:

{

if (this.telemetryEnabled) {

const body: protocol.TypingsInstalledTelemetryEventBody = {

telemetryEventName: "typingsInstalled",

payload: {

installedPackages: response.packagesToInstall.join(","),

installSuccess: response.installSuccess,

typingsInstallerVersion: response.typingsInstallerVersion

}

};

const eventName: protocol.TelemetryEventName = "telemetry";

this.event(body, eventName);

}

const body: protocol.EndInstallTypesEventBody = {

eventId: response.eventId,

packages: response.packagesToInstall,

success: response.installSuccess,

};

const eventName: protocol.EndInstallTypesEventName = "endInstallTypes";

this.event(body, eventName);

break;

}

case ActionInvalidate:

{

this.projectService.updateTypingsForProject(response);

break;

}

case ActionSet:

{

if (this.activeRequestCount > 0) {

this.activeRequestCount--;

}

else {

Debug.fail("Received too many responses");

}

while (this.requestQueue.length > 0) {

const queuedRequest = this.requestQueue.shift();

if (this.requestMap.get(queuedRequest.operationId) === queuedRequest) {

this.requestMap.delete(queuedRequest.operationId);

this.scheduleRequest(queuedRequest);

break;

}

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Skipping defunct request for: ${queuedRequest.operationId}`);

}

}

this.projectService.updateTypingsForProject(response);

this.event(response, "setTypings");

break;

}

default:

assertTypeIsNever(response);

}

}

private scheduleRequest(request: QueuedOperation) {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Scheduling request for: ${request.operationId}`);

}

this.activeRequestCount++;

this.host.setTimeout(request.operation, NodeTypingsInstaller.requestDelayMillis);

}

private eventPort: number;

private eventSocket: NodeSocket | undefined;

private socketEventQueue: { body: any, eventName: string }[] | undefined;

private constructed: boolean | undefined;

constructor() {

const event: Event | undefined = (body: object, eventName: string) => {

if (this.constructed) {

this.event(body, eventName);

}

else {

// It is unsafe to dereference `this` before initialization completes,

// so we defer until the next tick.

//

// Construction should finish before the next tick fires, so we do not need to do this recursively.

setImmediate(() => this.event(body, eventName));

}

};

const host = sys;

const typingsInstaller = disableAutomaticTypingAcquisition

? undefined

: new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, event);

super({

host,

cancellationToken,

useSingleInferredProject,

useInferredProjectPerProjectRoot,

typingsInstaller: typingsInstaller || nullTypingsInstaller,

byteLength: Buffer.byteLength,

hrtime: process.hrtime,

logger,

canUseEvents: true,

suppressDiagnosticEvents,

globalPlugins,

pluginProbeLocations,

allowLocalPluginLoads,

});

this.eventPort = eventPort;

if (this.canUseEvents && this.eventPort) {

const s = net.connect({ port: this.eventPort }, () => {

this.eventSocket = s;

if (this.socketEventQueue) {

// flush queue.

for (const event of this.socketEventQueue) {

this.writeToEventSocket(event.body, event.eventName);

}

this.socketEventQueue = undefined;

}

});

}

this.constructed = true;

}

event<T extends object>(body: T, eventName: string): void {

Debug.assert(this.constructed, "Should only call `IOSession.prototype.event` on an initialized IOSession");

if (this.canUseEvents && this.eventPort) {

if (!this.eventSocket) {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`eventPort: event "${eventName}" queued, but socket not yet initialized`);

}

(this.socketEventQueue || (this.socketEventQueue = [])).push({ body, eventName });

return;

}

else {

Debug.assert(this.socketEventQueue === undefined);

this.writeToEventSocket(body, eventName);

}

}

else {

super.event(body, eventName);

}

}

private writeToEventSocket(body: object, eventName: string): void {

this.eventSocket.write(formatMessage(toEvent(eventName, body), this.logger, this.byteLength, this.host.newLine), "utf8");

}

exit() {

this.logger.info("Exiting...");

this.projectService.closeLog();

process.exit(0);

}

listen() {

rl.on("line", (input: string) => {

const message = input.trim();

this.onMessage(message);

});

rl.on("close", () => {

this.exit();

});

}

file?: string;

detailLevel?: LogLevel;

traceToConsole?: boolean;

logToFile?: boolean;

if (!logEnvStr) {

return {};

}

const logEnv: LogOptions = { logToFile: true };

const args = logEnvStr.split(" ");

const len = args.length - 1;

for (let i = 0; i < len; i += 2) {

const option = args[i];

const value = args[i + 1];

if (option && value) {

switch (option) {

case "-file":

logEnv.file = stripQuotes(value);

break;

case "-level":

const level = getLogLevel(value);

logEnv.detailLevel = level !== undefined ? level : LogLevel.normal;

break;

case "-traceToConsole":

logEnv.traceToConsole = value.toLowerCase() === "true";

break;

case "-logToFile":

logEnv.logToFile = value.toLowerCase() === "true";

break;

}

}

}

return logEnv;

if (level) {

const l = level.toLowerCase();

for (const name in LogLevel) {

if (isNaN(+name) && l === name.toLowerCase()) {

return <LogLevel><any>LogLevel[name];

}

}

}

return undefined;

const cmdLineLogFileName = findArgument("--logFile");

const cmdLineVerbosity = getLogLevel(findArgument("--logVerbosity"));

const envLogOptions = parseLoggingEnvironmentString(process.env.TSS_LOG);

const logFileName = cmdLineLogFileName

? stripQuotes(cmdLineLogFileName)

: envLogOptions.logToFile

? envLogOptions.file || (__dirname + "/.log" + process.pid.toString())

: undefined;

const logVerbosity = cmdLineVerbosity || envLogOptions.detailLevel;

return new Logger(logFileName, envLogOptions.traceToConsole, logVerbosity);

const watchedFiles: WatchedFile[] = [];

let nextFileToCheck = 0;

return { getModifiedTime, poll, startWatchTimer, addFile, removeFile };

function getModifiedTime(fileName: string): Date {

return fs.statSync(fileName).mtime;

}

function poll(checkedIndex: number) {

const watchedFile = watchedFiles[checkedIndex];

if (!watchedFile) {

return;

}

fs.stat(watchedFile.fileName, (err, stats) => {

if (err) {

if (err.code === "ENOENT") {

if (watchedFile.mtime.getTime() !== 0) {

watchedFile.mtime = missingFileModifiedTime;

watchedFile.callback(watchedFile.fileName, FileWatcherEventKind.Deleted);

}

}

else {

watchedFile.callback(watchedFile.fileName, FileWatcherEventKind.Changed);

}

}

else {

onWatchedFileStat(watchedFile, stats.mtime);

}

});

}

// this implementation uses polling and

// stat due to inconsistencies of fs.watch

// and efficiency of stat on modern filesystems

function startWatchTimer() {

setInterval(() => {

let count = 0;

let nextToCheck = nextFileToCheck;

let firstCheck = -1;

while ((count < chunkSize) && (nextToCheck !== firstCheck)) {

poll(nextToCheck);

if (firstCheck < 0) {

firstCheck = nextToCheck;

}

nextToCheck++;

if (nextToCheck === watchedFiles.length) {

nextToCheck = 0;

}

count++;

}

nextFileToCheck = nextToCheck;

}, interval);

}

function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {

const file: WatchedFile = {

fileName,

callback,

mtime: sys.fileExists(fileName)

? getModifiedTime(fileName)

: missingFileModifiedTime // Any subsequent modification will occur after this time

};

watchedFiles.push(file);

if (watchedFiles.length === 1) {

startWatchTimer();

}

return file;

}

function removeFile(file: WatchedFile) {

unorderedRemoveItem(watchedFiles, file);

}

if (!canWrite) {

pending.push(buf);

}

else {

canWrite = false;

process.stdout.write(buf, setCanWriteFlagAndWriteMessageIfNecessary);

}

canWrite = true;

if (pending.length) {

writeMessage(pending.shift());

}

path = normalizeSlashes(path);

if (isUNCPath(path)) {

// UNC path: extract server name

// //server/location

// ^ <- from 0 to this position

const firstSlash = path.indexOf(directorySeparator, 2);

return firstSlash !== -1 ? path.substring(0, firstSlash).toLowerCase() : path;

}

const rootLength = getRootLength(path);

if (rootLength === 0) {

// relative path - assume file is on the current drive

return currentDriveKey;

}

if (path.charCodeAt(1) === CharacterCodes.colon && path.charCodeAt(2) === CharacterCodes.slash) {

// rooted path that starts with c:/... - extract drive letter

return path.charAt(0).toLowerCase();

}

if (path.charCodeAt(0) === CharacterCodes.slash && path.charCodeAt(1) !== CharacterCodes.slash) {

// rooted path that starts with slash - /somename - use key for current drive

return currentDriveKey;

}

// do not cache any other cases

return undefined;