Merge from vscode e558dc6ea73a75bd69d7a0b485f0e7e4194c66bf (#6864)

src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts

@@ -330,6 +330,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 		return {
 			label: data.a,
 			kind: data.b,
+			kindModifier: data.n ? modes.CompletionItemKindModifier.Deprecated : undefined,
 			detail: data.c,
 			documentation: data.d,
 			sortText: data.e,
@@ -366,7 +367,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 		};
 		if (supportsResolveDetails) {
 			provider.resolveCompletionItem = (model, position, suggestion, token) => {
-				return this._proxy.$resolveCompletionItem(handle, model.uri, position, suggestion._id, token).then(result => {
+				return this._proxy.$resolveCompletionItem(handle, model.uri, position, suggestion._id!, token).then(result => {
 					if (!result) {
 						return suggestion;
 					}

src/vs/workbench/api/browser/mainThreadLogService.ts

@@ -3,20 +3,46 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { ILogService } from 'vs/platform/log/common/log';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { IExtHostContext, ExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ILogService, LogLevel } from 'vs/platform/log/common/log';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IExtHostContext, ExtHostContext, MainThreadLogShape, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { UriComponents, URI } from 'vs/base/common/uri';
+import { FileLogService } from 'vs/platform/log/common/fileLogService';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { basename } from 'vs/base/common/path';
 
-@extHostCustomer
-export class MainThreadLogService extends Disposable {
+@extHostNamedCustomer(MainContext.MainThreadLog)
+export class MainThreadLogService implements MainThreadLogShape {
+
+	private readonly _loggers = new Map<string, FileLogService>();
+	private readonly _logListener: IDisposable;
 
 	constructor(
 		extHostContext: IExtHostContext,
-		@ILogService logService: ILogService,
+		@ILogService private readonly _logService: ILogService,
+		@IInstantiationService private readonly _instaService: IInstantiationService,
 	) {
-		super();
-		this._register(logService.onDidChangeLogLevel(level => extHostContext.getProxy(ExtHostContext.ExtHostLogService).$setLevel(level)));
+		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostLogService);
+		this._logListener = _logService.onDidChangeLogLevel(level => {
+			proxy.$setLevel(level);
+			this._loggers.forEach(value => value.setLevel(level));
+		});
 	}
 
-}
+	dispose(): void {
+		this._logListener.dispose();
+		this._loggers.forEach(value => value.dispose());
+		this._loggers.clear();
+	}
+
+	$log(file: UriComponents, level: LogLevel, message: any[]): void {
+		const uri = URI.revive(file);
+		let logger = this._loggers.get(uri.toString());
+		if (!logger) {
+			logger = this._instaService.createInstance(FileLogService, basename(file.path), URI.revive(file), this._logService.getLevel());
+			this._loggers.set(uri.toString(), logger);
+		}
+		logger.log(level, message);
+	}
+}

src/vs/workbench/api/browser/mainThreadWebview.ts

@@ -292,7 +292,7 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 					viewStates[handle] = {
 						visible: input === group.activeEditor,
 						active: input === activeInput,
-						position: editorGroupToViewColumn(this._editorGroupService, group.id || 0),
+						position: editorGroupToViewColumn(this._editorGroupService, group.id),
 					};
 				}
 			}
@@ -304,10 +304,6 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 	}
 
 	private onDidClickLink(handle: WebviewPanelHandle, link: URI): void {
-		if (!link) {
-			return;
-		}
-
 		const webview = this.getWebviewEditorInput(handle);
 		if (this.isSupportedLink(webview, link)) {
 			this._openerService.open(link);

src/vs/workbench/api/common/extHost.protocol.ts

@@ -939,6 +939,7 @@ export interface ISuggestDataDto {
 	k/* commitCharacters */?: string[];
 	l/* additionalTextEdits */?: ISingleEditOperation[];
 	m/* command */?: modes.Command;
+	n/* deprecated */?: boolean;
 	// not-standard
 	x?: ChainedCacheId;
 }
@@ -1287,6 +1288,10 @@ export interface ExtHostLogServiceShape {
 	$setLevel(level: LogLevel): void;
 }
 
+export interface MainThreadLogShape {
+	$log(file: UriComponents, level: LogLevel, args: any[]): void;
+}
+
 export interface ExtHostOutputServiceShape {
 	$setVisibleChannel(channelId: string | null): void;
 }
@@ -1329,6 +1334,7 @@ export const MainContext = {
 	MainThreadKeytar: createMainId<MainThreadKeytarShape>('MainThreadKeytar'),
 	MainThreadLanguageFeatures: createMainId<MainThreadLanguageFeaturesShape>('MainThreadLanguageFeatures'),
 	MainThreadLanguages: createMainId<MainThreadLanguagesShape>('MainThreadLanguages'),
+	MainThreadLog: createMainId<MainThreadLogShape>('MainThread'),
 	MainThreadMessageService: createMainId<MainThreadMessageServiceShape>('MainThreadMessageService'),
 	MainThreadOutputService: createMainId<MainThreadOutputServiceShape>('MainThreadOutputService'),
 	MainThreadProgress: createMainId<MainThreadProgressShape>('MainThreadProgress'),

src/vs/workbench/api/common/extHostLanguageFeatures.ts

@@ -736,6 +736,7 @@ class SuggestAdapter {
 			k: item.commitCharacters,
 			l: item.additionalTextEdits && item.additionalTextEdits.map(typeConvert.TextEdit.from),
 			m: this._commands.toInternal(item.command, disposables),
+			n: item.deprecated
 		};
 
 		// 'insertText'-logic

src/vs/workbench/api/worker/extHostExtensionService.ts

@@ -8,7 +8,6 @@ import { ExtensionActivationTimesBuilder } from 'vs/workbench/api/common/extHost
 import { AbstractExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
 import { endsWith, startsWith } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
-import { Schemas } from 'vs/base/common/network';
 import { joinPath } from 'vs/base/common/resources';
 import { RequireInterceptor } from 'vs/workbench/api/common/extHostRequireInterceptor';
 
@@ -128,7 +127,7 @@ export class ExtHostExtensionService extends AbstractExtHostExtensionService {
 			const next = joinPath(parent, '..', ensureSuffix(mod, '.js'));
 			moduleStack.push(next);
 			const trap = ExportsTrap.Instance.add(next.toString());
-			importScripts(asDomUri(next).toString(true));
+			importScripts(next.toString(true));
 			moduleStack.pop();
 
 			return trap.claim();
@@ -139,7 +138,7 @@ export class ExtHostExtensionService extends AbstractExtHostExtensionService {
 			module = module.with({ path: ensureSuffix(module.path, '.js') });
 			moduleStack.push(module);
 			const trap = ExportsTrap.Instance.add(module.toString());
-			importScripts(asDomUri(module).toString(true));
+			importScripts(module.toString(true));
 			moduleStack.pop();
 			return Promise.resolve<T>(trap.claim());
 
@@ -153,16 +152,6 @@ export class ExtHostExtensionService extends AbstractExtHostExtensionService {
 	}
 }
 
-// todo@joh this is a copy of `dom.ts#asDomUri`
-function asDomUri(uri: URI): URI {
-	if (Schemas.vscodeRemote === uri.scheme) {
-		// rewrite vscode-remote-uris to uris of the window location
-		// so that they can be intercepted by the service worker
-		return URI.parse(window.location.href).with({ path: '/vscode-remote', query: JSON.stringify(uri) });
-	}
-	return uri;
-}
-
 function ensureSuffix(path: string, suffix: string): string {
 	return endsWith(path, suffix) ? path : path + suffix;
 }

src/vs/workbench/api/worker/extHostLogService.ts

@@ -4,24 +4,33 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ILogService, LogLevel, AbstractLogService } from 'vs/platform/log/common/log';
-import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostLogServiceShape, MainThreadLogShape, MainContext } from 'vs/workbench/api/common/extHost.protocol';
 import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
 import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
-import * as vscode from 'vscode';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { joinPath } from 'vs/base/common/resources';
+import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
+import { UriComponents } from 'vs/base/common/uri';
+import { localize } from 'vs/nls';
 
 export class ExtHostLogService extends AbstractLogService implements ILogService, ExtHostLogServiceShape {
 
 	_serviceBrand: any;
 
-	private readonly _logChannel: vscode.OutputChannel;
+	private readonly _proxy: MainThreadLogShape;
+	private readonly _logFile: UriComponents;
 
 	constructor(
+		@IExtHostRpcService rpc: IExtHostRpcService,
 		@IExtHostInitDataService initData: IExtHostInitDataService,
 		@IExtHostOutputService extHostOutputService: IExtHostOutputService
 	) {
 		super();
+		const logFile = joinPath(initData.logsLocation, `${ExtensionHostLogFileName}.log`);
+		this._proxy = rpc.getProxy(MainContext.MainThreadLog);
+		this._logFile = logFile.toJSON();
 		this.setLevel(initData.logLevel);
-		this._logChannel = extHostOutputService.createOutputChannel('Log (Worker Extension Host)');
+		extHostOutputService.createOutputChannelFromLogFile(localize('name', "Worker Extension Host"), logFile);
 	}
 
 	$setLevel(level: LogLevel): void {
@@ -30,55 +39,37 @@ export class ExtHostLogService extends AbstractLogService implements ILogService
 
 	trace(_message: string, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Trace) {
-			this._logChannel.appendLine(this._format(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Trace, Array.from(arguments));
 		}
 	}
 
 	debug(_message: string, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Debug) {
-			this._logChannel.appendLine(this._format(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Debug, Array.from(arguments));
 		}
 	}
 
 	info(_message: string, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Info) {
-			this._logChannel.appendLine(this._format(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Info, Array.from(arguments));
 		}
 	}
 
 	warn(_message: string, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Warning) {
-			this._logChannel.appendLine(this._format(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Warning, Array.from(arguments));
 		}
 	}
 
 	error(_message: string | Error, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Error) {
-			this._logChannel.appendLine(this._format(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Error, Array.from(arguments));
 		}
 	}
 
 	critical(_message: string | Error, ..._args: any[]): void {
 		if (this.getLevel() <= LogLevel.Critical) {
-			this._logChannel.appendLine(String(arguments));
+			this._proxy.$log(this._logFile, LogLevel.Critical, Array.from(arguments));
 		}
 	}
-
-	private _format(args: any): string {
-		let result = '';
-
-		for (let i = 0; i < args.length; i++) {
-			let a = args[i];
-
-			if (typeof a === 'object') {
-				try {
-					a = JSON.stringify(a);
-				} catch (e) { }
-			}
-
-			result += (i > 0 ? ' ' : '') + a;
-		}
-
-		return result;
-	}
 }