Merge VS Code 1.21 source code (#1067)

* Initial VS Code 1.21 file copy with patches

* A few more merges

* Post npm install

* Fix batch of build breaks

* Fix more build breaks

* Fix more build errors

* Fix more build breaks

* Runtime fixes 1

* Get connection dialog working with some todos

* Fix a few packaging issues

* Copy several node_modules to package build to fix loader issues

* Fix breaks from master

* A few more fixes

* Make tests pass

* First pass of license header updates

* Second pass of license header updates

* Fix restore dialog issues

* Remove add additional themes menu items

* fix select box issues where the list doesn't show up

* formatting

* Fix editor dispose issue

* Copy over node modules to correct location on all platforms

src/vs/platform/log/common/bufferLog.ts

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ILogService, LogLevel, AbstractLogService } from 'vs/platform/log/common/log';
+
+interface ILog {
+	level: LogLevel;
+	args: IArguments;
+}
+
+function getLogFunction(logger: ILogService, level: LogLevel): Function {
+	switch (level) {
+		case LogLevel.Trace: return logger.trace;
+		case LogLevel.Debug: return logger.debug;
+		case LogLevel.Info: return logger.info;
+		case LogLevel.Warning: return logger.warn;
+		case LogLevel.Error: return logger.error;
+		case LogLevel.Critical: return logger.critical;
+		default: throw new Error('Invalid log level');
+	}
+}
+
+export class BufferLogService extends AbstractLogService implements ILogService {
+
+	_serviceBrand: any;
+	private buffer: ILog[] = [];
+	private _logger: ILogService | undefined = undefined;
+
+	set logger(logger: ILogService) {
+		this._logger = logger;
+
+		for (const { level, args } of this.buffer) {
+			const fn = getLogFunction(logger, level);
+			fn.apply(logger, args);
+		}
+
+		this.buffer = [];
+	}
+
+	private _log(level: LogLevel, args: IArguments): void {
+		if (this._logger) {
+			const fn = getLogFunction(this._logger, level);
+			fn.apply(this._logger, args);
+		} else if (this.getLevel() <= level) {
+			this.buffer.push({ level, args });
+		}
+	}
+
+	trace(): void {
+		this._log(LogLevel.Trace, arguments);
+	}
+
+	debug(): void {
+		this._log(LogLevel.Debug, arguments);
+	}
+
+	info(): void {
+		this._log(LogLevel.Info, arguments);
+	}
+
+	warn(): void {
+		this._log(LogLevel.Warning, arguments);
+	}
+
+	error(): void {
+		this._log(LogLevel.Error, arguments);
+	}
+
+	critical(): void {
+		this._log(LogLevel.Critical, arguments);
+	}
+
+	dispose(): void {
+		if (this._logger) {
+			this._logger.dispose();
+		}
+	}
+}

src/vs/platform/log/common/log.ts

@@ -5,10 +5,11 @@
 
 'use strict';
 
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { createDecorator as createServiceDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
 import { isWindows } from 'vs/base/common/platform';
+import Event, { Emitter } from 'vs/base/common/event';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 
 export const ILogService = createServiceDecorator<ILogService>('logService');
 
@@ -22,11 +23,14 @@ export enum LogLevel {
 	Off
 }
 
+export const DEFAULT_LOG_LEVEL: LogLevel = LogLevel.Info;
+
 export interface ILogService extends IDisposable {
 	_serviceBrand: any;
+	onDidChangeLogLevel: Event<LogLevel>;
 
-	setLevel(level: LogLevel): void;
 	getLevel(): LogLevel;
+	setLevel(level: LogLevel): void;
 	trace(message: string, ...args: any[]): void;
 	debug(message: string, ...args: any[]): void;
 	info(message: string, ...args: any[]): void;
@@ -35,27 +39,37 @@ export interface ILogService extends IDisposable {
 	critical(message: string | Error, ...args: any[]): void;
 }
 
-export class ConsoleLogMainService implements ILogService {
+export abstract class AbstractLogService extends Disposable {
 
-	_serviceBrand: any;
-	private level: LogLevel = LogLevel.Error;
-	private useColors: boolean;
-
-	constructor( @IEnvironmentService environmentService: IEnvironmentService) {
-		this.setLevel(environmentService.logLevel);
-		this.useColors = !isWindows;
-	}
+	private level: LogLevel = DEFAULT_LOG_LEVEL;
+	private readonly _onDidChangeLogLevel: Emitter<LogLevel> = this._register(new Emitter<LogLevel>());
+	readonly onDidChangeLogLevel: Event<LogLevel> = this._onDidChangeLogLevel.event;
 
 	setLevel(level: LogLevel): void {
-		this.level = level;
+		if (this.level !== level) {
+			this.level = level;
+			this._onDidChangeLogLevel.fire(this.level);
+		}
 	}
 
 	getLevel(): LogLevel {
 		return this.level;
 	}
+}
+
+export class ConsoleLogMainService extends AbstractLogService implements ILogService {
+
+	_serviceBrand: any;
+	private useColors: boolean;
+
+	constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL) {
+		super();
+		this.setLevel(logLevel);
+		this.useColors = !isWindows;
+	}
 
 	trace(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Trace) {
+		if (this.getLevel() <= LogLevel.Trace) {
 			if (this.useColors) {
 				console.log(`\x1b[90m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -65,7 +79,7 @@ export class ConsoleLogMainService implements ILogService {
 	}
 
 	debug(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Debug) {
+		if (this.getLevel() <= LogLevel.Debug) {
 			if (this.useColors) {
 				console.log(`\x1b[90m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -75,7 +89,7 @@ export class ConsoleLogMainService implements ILogService {
 	}
 
 	info(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Info) {
+		if (this.getLevel() <= LogLevel.Info) {
 			if (this.useColors) {
 				console.log(`\x1b[90m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -85,7 +99,7 @@ export class ConsoleLogMainService implements ILogService {
 	}
 
 	warn(message: string | Error, ...args: any[]): void {
-		if (this.level <= LogLevel.Warning) {
+		if (this.getLevel() <= LogLevel.Warning) {
 			if (this.useColors) {
 				console.warn(`\x1b[93m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -95,7 +109,7 @@ export class ConsoleLogMainService implements ILogService {
 	}
 
 	error(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Error) {
+		if (this.getLevel() <= LogLevel.Error) {
 			if (this.useColors) {
 				console.error(`\x1b[91m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -105,7 +119,7 @@ export class ConsoleLogMainService implements ILogService {
 	}
 
 	critical(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Critical) {
+		if (this.getLevel() <= LogLevel.Critical) {
 			if (this.useColors) {
 				console.error(`\x1b[90m[main ${new Date().toLocaleTimeString()}]\x1b[0m`, message, ...args);
 			} else {
@@ -119,55 +133,47 @@ export class ConsoleLogMainService implements ILogService {
 	}
 }
 
-export class ConsoleLogService implements ILogService {
+export class ConsoleLogService extends AbstractLogService implements ILogService {
 
 	_serviceBrand: any;
-	private level: LogLevel = LogLevel.Error;
 
-	constructor( @IEnvironmentService environmentService: IEnvironmentService) {
-		this.setLevel(environmentService.logLevel);
-	}
-
-	setLevel(level: LogLevel): void {
-		this.level = level;
-	}
-
-	getLevel(): LogLevel {
-		return this.level;
+	constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL) {
+		super();
+		this.setLevel(logLevel);
 	}
 
 	trace(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Trace) {
+		if (this.getLevel() <= LogLevel.Trace) {
 			console.log('%cTRACE', 'color: #888', message, ...args);
 		}
 	}
 
 	debug(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Debug) {
+		if (this.getLevel() <= LogLevel.Debug) {
 			console.log('%cDEBUG', 'background: #eee; color: #888', message, ...args);
 		}
 	}
 
 	info(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Info) {
+		if (this.getLevel() <= LogLevel.Info) {
 			console.log('%c INFO', 'color: #33f', message, ...args);
 		}
 	}
 
 	warn(message: string | Error, ...args: any[]): void {
-		if (this.level <= LogLevel.Warning) {
+		if (this.getLevel() <= LogLevel.Warning) {
 			console.log('%c WARN', 'color: #993', message, ...args);
 		}
 	}
 
 	error(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Error) {
+		if (this.getLevel() <= LogLevel.Error) {
 			console.log('%c  ERR', 'color: #f33', message, ...args);
 		}
 	}
 
 	critical(message: string, ...args: any[]): void {
-		if (this.level <= LogLevel.Critical) {
+		if (this.getLevel() <= LogLevel.Critical) {
 			console.log('%cCRITI', 'background: #f33; color: white', message, ...args);
 		}
 	}
@@ -175,22 +181,21 @@ export class ConsoleLogService implements ILogService {
 	dispose(): void { }
 }
 
-export class MultiplexLogService implements ILogService {
+export class MultiplexLogService extends AbstractLogService implements ILogService {
 	_serviceBrand: any;
 
-	constructor(private logServices: ILogService[]) { }
+	constructor(private logServices: ILogService[]) {
+		super();
+		if (logServices.length) {
+			this.setLevel(logServices[0].getLevel());
+		}
+	}
 
 	setLevel(level: LogLevel): void {
 		for (const logService of this.logServices) {
 			logService.setLevel(level);
 		}
-	}
-
-	getLevel(): LogLevel {
-		for (const logService of this.logServices) {
-			return logService.getLevel();
-		}
-		return LogLevel.Info;
+		super.setLevel(level);
 	}
 
 	trace(message: string, ...args: any[]): void {
@@ -236,8 +241,54 @@ export class MultiplexLogService implements ILogService {
 	}
 }
 
-export class NoopLogService implements ILogService {
+export class DelegatedLogService extends Disposable implements ILogService {
 	_serviceBrand: any;
+
+	constructor(private logService: ILogService) {
+		super();
+		this._register(logService);
+	}
+
+	get onDidChangeLogLevel(): Event<LogLevel> {
+		return this.logService.onDidChangeLogLevel;
+	}
+
+	setLevel(level: LogLevel): void {
+		this.logService.setLevel(level);
+	}
+
+	getLevel(): LogLevel {
+		return this.logService.getLevel();
+	}
+
+	trace(message: string, ...args: any[]): void {
+		this.logService.trace(message, ...args);
+	}
+
+	debug(message: string, ...args: any[]): void {
+		this.logService.debug(message, ...args);
+	}
+
+	info(message: string, ...args: any[]): void {
+		this.logService.info(message, ...args);
+	}
+
+	warn(message: string, ...args: any[]): void {
+		this.logService.warn(message, ...args);
+	}
+
+	error(message: string | Error, ...args: any[]): void {
+		this.logService.error(message, ...args);
+	}
+
+	critical(message: string | Error, ...args: any[]): void {
+		this.logService.critical(message, ...args);
+	}
+}
+
+export class NullLogService implements ILogService {
+	_serviceBrand: any;
+	readonly onDidChangeLogLevel: Event<LogLevel> = new Emitter<LogLevel>().event;
 	setLevel(level: LogLevel): void { }
 	getLevel(): LogLevel { return LogLevel.Info; }
 	trace(message: string, ...args: any[]): void { }
@@ -248,3 +299,30 @@ export class NoopLogService implements ILogService {
 	critical(message: string | Error, ...args: any[]): void { }
 	dispose(): void { }
 }
+
+
+export function getLogLevel(environmentService: IEnvironmentService): LogLevel {
+	if (environmentService.verbose) {
+		return LogLevel.Trace;
+	}
+	if (typeof environmentService.args.log === 'string') {
+		const logLevel = environmentService.args.log.toLowerCase();
+		switch (logLevel) {
+			case 'trace':
+				return LogLevel.Trace;
+			case 'debug':
+				return LogLevel.Debug;
+			case 'info':
+				return LogLevel.Info;
+			case 'warn':
+				return LogLevel.Warning;
+			case 'error':
+				return LogLevel.Error;
+			case 'critical':
+				return LogLevel.Critical;
+			case 'off':
+				return LogLevel.Off;
+		}
+	}
+	return DEFAULT_LOG_LEVEL;
+}

src/vs/platform/log/common/logIpc.ts

@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IChannel, eventToCall, eventFromCall } from 'vs/base/parts/ipc/common/ipc';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { LogLevel, ILogService, DelegatedLogService } from 'vs/platform/log/common/log';
+import Event, { buffer } from 'vs/base/common/event';
+
+export interface ILogLevelSetterChannel extends IChannel {
+	call(command: 'event:onDidChangeLogLevel'): TPromise<LogLevel>;
+	call(command: 'setLevel', logLevel: LogLevel): TPromise<void>;
+}
+
+export class LogLevelSetterChannel implements ILogLevelSetterChannel {
+
+	onDidChangeLogLevel: Event<LogLevel>;
+
+	constructor(private service: ILogService) {
+		this.onDidChangeLogLevel = buffer(service.onDidChangeLogLevel, true);
+	}
+
+	call(command: string, arg?: any): TPromise<any> {
+		switch (command) {
+			case 'event:onDidChangeLogLevel': return eventToCall(this.onDidChangeLogLevel);
+			case 'setLevel': this.service.setLevel(arg); return TPromise.as(null);
+		}
+		return undefined;
+	}
+}
+
+export class LogLevelSetterChannelClient {
+
+	constructor(private channel: ILogLevelSetterChannel) { }
+
+	private _onDidChangeLogLevel = eventFromCall<LogLevel>(this.channel, 'event:onDidChangeLogLevel');
+	get onDidChangeLogLevel(): Event<LogLevel> { return this._onDidChangeLogLevel; }
+
+	setLevel(level: LogLevel): TPromise<void> {
+		return this.channel.call('setLevel', level);
+	}
+}
+
+export class FollowerLogService extends DelegatedLogService implements ILogService {
+	_serviceBrand: any;
+
+	constructor(private master: LogLevelSetterChannelClient, logService: ILogService) {
+		super(logService);
+		this._register(master.onDidChangeLogLevel(level => logService.setLevel(level)));
+	}
+
+	setLevel(level: LogLevel): void {
+		this.master.setLevel(level);
+	}
+}

src/vs/platform/log/node/spdlogService.ts

@@ -6,68 +6,61 @@
 'use strict';
 
 import * as path from 'path';
-import { ILogService, LogLevel, NoopLogService } from 'vs/platform/log/common/log';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ILogService, LogLevel, NullLogService, AbstractLogService } from 'vs/platform/log/common/log';
 import { RotatingLogger, setAsyncMode } from 'spdlog';
 
-export function createLogService(processName: string, environmentService: IEnvironmentService): ILogService {
+export function createSpdLogService(processName: string, logLevel: LogLevel, logsFolder: string): ILogService {
 	try {
 		setAsyncMode(8192, 2000);
-		const logfilePath = path.join(environmentService.logsPath, `${processName}.log`);
+		const logfilePath = path.join(logsFolder, `${processName}.log`);
 		const logger = new RotatingLogger(processName, logfilePath, 1024 * 1024 * 5, 6);
 		logger.setLevel(0);
 
-		return new SpdLogService(logger, environmentService.logLevel);
+		return new SpdLogService(logger, logLevel);
 	} catch (e) {
 		console.error(e);
 	}
-	return new NoopLogService();
+	return new NullLogService();
 }
 
-class SpdLogService implements ILogService {
+class SpdLogService extends AbstractLogService implements ILogService {
 
 	_serviceBrand: any;
 
 	constructor(
 		private readonly logger: RotatingLogger,
-		private level: LogLevel = LogLevel.Error
+		level: LogLevel = LogLevel.Error
 	) {
-	}
-
-	setLevel(logLevel: LogLevel): void {
-		this.level = logLevel;
-	}
-
-	getLevel(): LogLevel {
-		return this.level;
+		super();
+		this.setLevel(level);
 	}
 
 	trace(): void {
-		if (this.level <= LogLevel.Trace) {
+		if (this.getLevel() <= LogLevel.Trace) {
 			this.logger.trace(this.format(arguments));
 		}
 	}
 
 	debug(): void {
-		if (this.level <= LogLevel.Debug) {
+		if (this.getLevel() <= LogLevel.Debug) {
 			this.logger.debug(this.format(arguments));
 		}
 	}
 
 	info(): void {
-		if (this.level <= LogLevel.Info) {
+		if (this.getLevel() <= LogLevel.Info) {
 			this.logger.info(this.format(arguments));
 		}
 	}
 
 	warn(): void {
-		if (this.level <= LogLevel.Warning) {
+		if (this.getLevel() <= LogLevel.Warning) {
 			this.logger.warn(this.format(arguments));
 		}
 	}
 
 	error(): void {
-		if (this.level <= LogLevel.Error) {
+		if (this.getLevel() <= LogLevel.Error) {
 			const arg = arguments[0];
 
 			if (arg instanceof Error) {
@@ -81,13 +74,12 @@ class SpdLogService implements ILogService {
 	}
 
 	critical(): void {
-		if (this.level <= LogLevel.Critical) {
+		if (this.getLevel() <= LogLevel.Critical) {
 			this.logger.critical(this.format(arguments));
 		}
 	}
 
 	dispose(): void {
-		this.logger.flush();
 		this.logger.drop();
 	}