Merge from vscode 2b0b9136329c181a9e381463a1f7dc3a2d105a34 (#4880)

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

@@ -109,40 +109,48 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 	private _onDidChangeLabel = new Emitter<string>();
 	get onDidChangeLabel(): Event<string> { return this._onDidChangeLabel.event; }
 
+	private _comments: modes.Comment[] | undefined;
 
-	public get comments(): modes.Comment[] {
+	public get comments(): modes.Comment[] | undefined {
 		return this._comments;
 	}
 
-	public set comments(newComments: modes.Comment[]) {
+	public set comments(newComments: modes.Comment[] | undefined) {
 		this._comments = newComments;
 		this._onDidChangeComments.fire(this._comments);
 	}
 
-	private _onDidChangeComments = new Emitter<modes.Comment[]>();
-	get onDidChangeComments(): Event<modes.Comment[]> { return this._onDidChangeComments.event; }
+	private _onDidChangeComments = new Emitter<modes.Comment[] | undefined>();
+	get onDidChangeComments(): Event<modes.Comment[] | undefined> { return this._onDidChangeComments.event; }
 
-	set acceptInputCommand(newCommand: modes.Command) {
+	private _acceptInputCommand: modes.Command | undefined;
+	set acceptInputCommand(newCommand: modes.Command | undefined) {
 		this._acceptInputCommand = newCommand;
 		this._onDidChangeAcceptInputCommand.fire(this._acceptInputCommand);
 	}
 
-	get acceptInputCommand(): modes.Command {
+	get acceptInputCommand(): modes.Command | undefined {
 		return this._acceptInputCommand!;
 	}
 
-	private _onDidChangeAcceptInputCommand = new Emitter<modes.Command>();
-	get onDidChangeAcceptInputCommand(): Event<modes.Command> { return this._onDidChangeAcceptInputCommand.event; }
+	private _onDidChangeAcceptInputCommand = new Emitter<modes.Command | undefined>();
+	get onDidChangeAcceptInputCommand(): Event<modes.Command | undefined> { return this._onDidChangeAcceptInputCommand.event; }
 
-	set additionalCommands(newCommands: modes.Command[]) {
+	private _additionalCommands: modes.Command[] | undefined;
+	set additionalCommands(newCommands: modes.Command[] | undefined) {
 		this._additionalCommands = newCommands;
 		this._onDidChangeAdditionalCommands.fire(this._additionalCommands);
 	}
 
-	get additionalCommands(): modes.Command[] {
+	get additionalCommands(): modes.Command[] | undefined {
 		return this._additionalCommands;
 	}
 
+	private _onDidChangeAdditionalCommands = new Emitter<modes.Command[] | undefined>();
+	get onDidChangeAdditionalCommands(): Event<modes.Command[] | undefined> { return this._onDidChangeAdditionalCommands.event; }
+
+	private _deleteCommand: modes.Command | undefined;
+
 	set deleteCommand(newCommand: modes.Command | undefined) {
 		this._deleteCommand = newCommand;
 	}
@@ -151,9 +159,6 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 		return this._deleteCommand;
 	}
 
-	private _onDidChangeAdditionalCommands = new Emitter<modes.Command[]>();
-	get onDidChangeAdditionalCommands(): Event<modes.Command[]> { return this._onDidChangeAdditionalCommands.event; }
-
 	set range(range: IRange) {
 		this._range = range;
 		this._onDidChangeRange.fire(this._range);
@@ -166,16 +171,17 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 	private _onDidChangeRange = new Emitter<IRange>();
 	public onDidChangeRange = this._onDidChangeRange.event;
 
+	private _collapsibleState: modes.CommentThreadCollapsibleState | undefined;
 	get collapsibleState() {
 		return this._collapsibleState;
 	}
 
-	set collapsibleState(newState: modes.CommentThreadCollapsibleState) {
+	set collapsibleState(newState: modes.CommentThreadCollapsibleState | undefined) {
 		this._collapsibleState = newState;
 		this._onDidChangeCollasibleState.fire(this._collapsibleState);
 	}
 
-	private _onDidChangeCollasibleState = new Emitter<modes.CommentThreadCollapsibleState>();
+	private _onDidChangeCollasibleState = new Emitter<modes.CommentThreadCollapsibleState | undefined>();
 	public onDidChangeCollasibleState = this._onDidChangeCollasibleState.event;
 
 	constructor(
@@ -184,14 +190,24 @@ export class MainThreadCommentThread implements modes.CommentThread2 {
 		public extensionId: string,
 		public threadId: string,
 		public resource: string,
-		private _range: IRange,
-		private _comments: modes.Comment[],
-		private _acceptInputCommand: modes.Command | undefined,
-		private _additionalCommands: modes.Command[],
-		private _deleteCommand: modes.Command | undefined,
-		private _collapsibleState: modes.CommentThreadCollapsibleState
-	) {
+		private _range: IRange
+	) { }
 
+	batchUpdate(
+		range: IRange,
+		label: string,
+		comments: modes.Comment[],
+		acceptInputCommand: modes.Command | undefined,
+		additionalCommands: modes.Command[],
+		deleteCommand: modes.Command | undefined,
+		collapsibleState: modes.CommentThreadCollapsibleState) {
+		this._range = range;
+		this._label = label;
+		this._comments = comments;
+		this._acceptInputCommand = acceptInputCommand;
+		this._additionalCommands = additionalCommands;
+		this._deleteCommand = deleteCommand;
+		this._collapsibleState = collapsibleState;
 	}
 
 	dispose() { }
@@ -254,23 +270,14 @@ export class MainThreadCommentController {
 		threadId: string,
 		resource: UriComponents,
 		range: IRange,
-		comments: modes.Comment[],
-		acceptInputCommand: modes.Command | undefined,
-		additionalCommands: modes.Command[],
-		deleteCommand: modes.Command | undefined,
-		collapseState: modes.CommentThreadCollapsibleState): modes.CommentThread2 {
+	): modes.CommentThread2 {
 		let thread = new MainThreadCommentThread(
 			commentThreadHandle,
 			this,
 			'',
 			threadId,
 			URI.revive(resource).toString(),
-			range,
-			comments,
-			acceptInputCommand,
-			additionalCommands,
-			deleteCommand,
-			collapseState
+			range
 		);
 
 		this._threads.set(commentThreadHandle, thread);
@@ -284,6 +291,27 @@ export class MainThreadCommentController {
 		return thread;
 	}
 
+	updateCommentThread(commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		range: IRange,
+		label: string,
+		comments: modes.Comment[],
+		acceptInputCommand: modes.Command | undefined,
+		additionalCommands: modes.Command[],
+		deleteCommand: modes.Command | undefined,
+		collapsibleState: modes.CommentThreadCollapsibleState): void {
+		let thread = this.getKnownThread(commentThreadHandle);
+		thread.batchUpdate(range, label, comments, acceptInputCommand, additionalCommands, deleteCommand, collapsibleState);
+
+		this._commentService.updateComments(this._uniqueId, {
+			added: [],
+			removed: [],
+			changed: [thread],
+			draftMode: modes.DraftMode.NotSupported
+		});
+	}
+
 	deleteCommentThread(commentThreadHandle: number) {
 		let thread = this.getKnownThread(commentThreadHandle);
 		this._threads.delete(commentThreadHandle);
@@ -298,48 +326,6 @@ export class MainThreadCommentController {
 		thread.dispose();
 	}
 
-	updateComments(commentThreadHandle: number, comments: modes.Comment[]) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.comments = comments;
-
-		this._commentService.updateComments(this._uniqueId, {
-			added: [],
-			removed: [],
-			changed: [thread],
-			draftMode: modes.DraftMode.NotSupported
-		});
-	}
-
-	updateAcceptInputCommand(commentThreadHandle: number, acceptInputCommand: modes.Command) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.acceptInputCommand = acceptInputCommand;
-	}
-
-	updateAdditionalCommands(commentThreadHandle: number, additionalCommands: modes.Command[]) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.additionalCommands = additionalCommands;
-	}
-
-	updateDeleteCommand(commentThreadHandle: number, deleteCommand: modes.Command) {
-		const thread = this.getKnownThread(commentThreadHandle);
-		thread.deleteCommand = deleteCommand;
-	}
-
-	updateCollapsibleState(commentThreadHandle: number, collapseState: modes.CommentThreadCollapsibleState) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.collapsibleState = collapseState;
-	}
-
-	updateCommentThreadRange(commentThreadHandle: number, range: IRange) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.range = range;
-	}
-
-	updateCommentThreadLabel(commentThreadHandle: number, label: string) {
-		let thread = this.getKnownThread(commentThreadHandle);
-		thread.label = label;
-	}
-
 	updateInput(input: string) {
 		let thread = this.activeCommentThread;
 
@@ -358,7 +344,6 @@ export class MainThreadCommentController {
 		return thread;
 	}
 
-
 	async getDocumentComments(resource: URI, token: CancellationToken) {
 		let ret: modes.CommentThread2[] = [];
 		for (let thread of keys(this._threads)) {
@@ -499,19 +484,35 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		commentThreadHandle: number,
 		threadId: string,
 		resource: UriComponents,
-		range: IRange,
-		comments: modes.Comment[],
-		acceptInputCommand: modes.Command | undefined,
-		additionalCommands: modes.Command[],
-		deleteCommand: modes.Command,
-		collapseState: modes.CommentThreadCollapsibleState): modes.CommentThread2 | undefined {
+		range: IRange
+	): modes.CommentThread2 | undefined {
 		let provider = this._commentControllers.get(handle);
 
 		if (!provider) {
 			return undefined;
 		}
 
-		return provider.createCommentThread(commentThreadHandle, threadId, resource, range, comments, acceptInputCommand, additionalCommands, deleteCommand, collapseState);
+		return provider.createCommentThread(commentThreadHandle, threadId, resource, range);
+	}
+
+	$updateCommentThread(handle: number,
+		commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		range: IRange,
+		label: string,
+		comments: modes.Comment[],
+		acceptInputCommand: modes.Command | undefined,
+		additionalCommands: modes.Command[],
+		deleteCommand: modes.Command,
+		collapsibleState: modes.CommentThreadCollapsibleState): void {
+		let provider = this._commentControllers.get(handle);
+
+		if (!provider) {
+			return undefined;
+		}
+
+		return provider.updateCommentThread(commentThreadHandle, threadId, resource, range, label, comments, acceptInputCommand, additionalCommands, deleteCommand, collapsibleState);
 	}
 
 	$deleteCommentThread(handle: number, commentThreadHandle: number) {
@@ -524,16 +525,6 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		return provider.deleteCommentThread(commentThreadHandle);
 	}
 
-	$updateComments(handle: number, commentThreadHandle: number, comments: modes.Comment[]) {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateComments(commentThreadHandle, comments);
-	}
-
 	$setInputValue(handle: number, input: string) {
 		let provider = this._commentControllers.get(handle);
 
@@ -544,66 +535,6 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		provider.updateInput(input);
 	}
 
-	$updateCommentThreadAcceptInputCommand(handle: number, commentThreadHandle: number, acceptInputCommand: modes.Command) {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateAcceptInputCommand(commentThreadHandle, acceptInputCommand);
-	}
-
-	$updateCommentThreadAdditionalCommands(handle: number, commentThreadHandle: number, additionalCommands: modes.Command[]) {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateAdditionalCommands(commentThreadHandle, additionalCommands);
-	}
-
-	$updateCommentThreadDeleteCommand(handle: number, commentThreadHandle: number, acceptInputCommand: modes.Command) {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateDeleteCommand(commentThreadHandle, acceptInputCommand);
-	}
-
-	$updateCommentThreadCollapsibleState(handle: number, commentThreadHandle: number, collapseState: modes.CommentThreadCollapsibleState): void {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateCollapsibleState(commentThreadHandle, collapseState);
-	}
-
-	$updateCommentThreadRange(handle: number, commentThreadHandle: number, range: any): void {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateCommentThreadRange(commentThreadHandle, range);
-	}
-
-	$updateCommentThreadLabel(handle: number, commentThreadHandle: number, label: string): void {
-		let provider = this._commentControllers.get(handle);
-
-		if (!provider) {
-			return;
-		}
-
-		provider.updateCommentThreadLabel(commentThreadHandle, label);
-	}
-
 	$registerDocumentCommentProvider(handle: number, features: CommentProviderFeatures): void {
 		this._documentProviders.set(handle, undefined);
 		const handler = new MainThreadDocumentCommentProvider(this._proxy, handle, features);

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

@@ -9,8 +9,7 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { IRemoteConsoleLog, log, parse } from 'vs/base/common/console';
 import { parseExtensionDevOptions } from 'vs/workbench/services/extensions/common/extensionDevOptions';
 import { IWindowsService } from 'vs/platform/windows/common/windows';
-import { IBroadcastService } from 'vs/workbench/services/broadcast/common/broadcast';
-import { EXTENSION_LOG_BROADCAST_CHANNEL } from 'vs/platform/extensions/common/extensionHost';
+import { IExtensionHostDebugService } from 'vs/workbench/services/extensions/common/extensionHostDebug';
 
 @extHostNamedCustomer(MainContext.MainThreadConsole)
 export class MainThreadConsole implements MainThreadConsoleShape {
@@ -22,7 +21,7 @@ export class MainThreadConsole implements MainThreadConsoleShape {
 		extHostContext: IExtHostContext,
 		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
 		@IWindowsService private readonly _windowsService: IWindowsService,
-		@IBroadcastService private readonly _broadcastService: IBroadcastService,
+		@IExtensionHostDebugService private readonly _extensionHostDebugService: IExtensionHostDebugService,
 	) {
 		const devOpts = parseExtensionDevOptions(this._environmentService);
 		this._isExtensionDevHost = devOpts.isExtensionDevHost;
@@ -45,14 +44,8 @@ export class MainThreadConsole implements MainThreadConsoleShape {
 		}
 
 		// Broadcast to other windows if we are in development mode
-		else if (!this._environmentService.isBuilt || this._isExtensionDevHost) {
-			this._broadcastService.broadcast({
-				channel: EXTENSION_LOG_BROADCAST_CHANNEL,
-				payload: {
-					logEntry: entry,
-					debugId: this._environmentService.debugExtensionHost.debugId
-				}
-			});
+		else if (this._environmentService.debugExtensionHost.debugId && (!this._environmentService.isBuilt || this._isExtensionDevHost)) {
+			this._extensionHostDebugService.logToSession(this._environmentService.debugExtensionHost.debugId, entry);
 		}
 	}
 }

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

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainContext, MainThreadKeytarShape, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+
+interface IKeytarModule {
+	getPassword(service: string, account: string): Promise<string | null>;
+	setPassword(service: string, account: string, password: string): Promise<void>;
+	deletePassword(service: string, account: string): Promise<boolean>;
+	findPassword(service: string): Promise<string | null>;
+}
+
+@extHostNamedCustomer(MainContext.MainThreadKeytar)
+export class MainThreadKeytar implements MainThreadKeytarShape {
+
+	private _keytar: IKeytarModule | null;
+
+	constructor(
+		extHostContext: IExtHostContext
+	) {
+		try {
+			this._keytar = <IKeytarModule>require.__$__nodeRequire('keytar');
+		} catch (e) {
+			this._keytar = null;
+		}
+	}
+
+	dispose(): void {
+		//
+	}
+
+	async $getPassword(service: string, account: string): Promise<string | null> {
+		if (this._keytar) {
+			return this._keytar.getPassword(service, account);
+		}
+		return null;
+	}
+
+	async $setPassword(service: string, account: string, password: string): Promise<void> {
+		if (this._keytar) {
+			return this._keytar.setPassword(service, account, password);
+		}
+	}
+
+	async $deletePassword(service: string, account: string): Promise<boolean> {
+		if (this._keytar) {
+			return this._keytar.deletePassword(service, account);
+		}
+		return false;
+	}
+
+	async $findPassword(service: string): Promise<string | null> {
+		if (this._keytar) {
+			return this._keytar.findPassword(service);
+		}
+		return null;
+	}
+}

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

@@ -10,8 +10,8 @@ import * as modes from 'vs/editor/common/modes';
 import * as search from 'vs/workbench/contrib/search/common/search';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Position as EditorPosition } from 'vs/editor/common/core/position';
-import { Range as EditorRange } from 'vs/editor/common/core/range';
-import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ISerializedLanguageConfiguration, ISerializedRegExp, ISerializedIndentationRule, ISerializedOnEnterRule, LocationDto, WorkspaceSymbolDto, CodeActionDto, reviveWorkspaceEditDto, ISerializedDocumentFilter, DefinitionLinkDto, ISerializedSignatureHelpProviderMetadata, CodeInsetDto, LinkDto, CallHierarchyDto } from '../common/extHost.protocol';
+import { Range as EditorRange, IRange } from 'vs/editor/common/core/range';
+import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ISerializedLanguageConfiguration, ISerializedRegExp, ISerializedIndentationRule, ISerializedOnEnterRule, LocationDto, WorkspaceSymbolDto, CodeActionDto, reviveWorkspaceEditDto, ISerializedDocumentFilter, DefinitionLinkDto, ISerializedSignatureHelpProviderMetadata, CodeInsetDto, LinkDto, CallHierarchyDto, SuggestDataDto } from '../common/extHost.protocol';
 import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
 import { LanguageConfiguration, IndentationRule, OnEnterRule } from 'vs/editor/common/modes/languageConfiguration';
 import { IModeService } from 'vs/editor/common/services/modeService';
@@ -22,6 +22,7 @@ import * as codeInset from 'vs/workbench/contrib/codeinset/common/codeInset';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import * as callh from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
 import { IHeapService } from 'vs/workbench/services/heap/common/heap';
+import { mixin } from 'vs/base/common/objects';
 
 @extHostNamedCustomer(MainContext.MainThreadLanguageFeatures)
 export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesShape {
@@ -150,8 +151,8 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 					return dto;
 				});
 			},
-			resolveCodeLens: (model: ITextModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): Promise<modes.ICodeLensSymbol | undefined> => {
-				return this._proxy.$resolveCodeLens(handle, model.uri, codeLens, token).then(obj => {
+			resolveCodeLens: (_model: ITextModel, codeLens: modes.ICodeLensSymbol, token: CancellationToken): Promise<modes.ICodeLensSymbol | undefined> => {
+				return this._proxy.$resolveCodeLens(handle, codeLens, token).then(obj => {
 					if (obj) {
 						this._heapService.trackObject(obj);
 						this._heapService.trackObject(obj.command);
@@ -359,29 +360,56 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 
 	// --- suggest
 
+	private static _inflateSuggestDto(defaultRange: IRange, data: SuggestDataDto): modes.CompletionItem {
+		return {
+			label: data.a,
+			kind: data.b,
+			detail: data.c,
+			documentation: data.d,
+			sortText: data.e,
+			filterText: data.f,
+			preselect: data.g,
+			insertText: data.h || data.a,
+			insertTextRules: data.i,
+			range: data.j || defaultRange,
+			commitCharacters: data.k,
+			additionalTextEdits: data.l,
+			command: data.m,
+			// not-standard
+			_id: data.x,
+			_pid: data.y
+		};
+	}
+
 	$registerSuggestSupport(handle: number, selector: ISerializedDocumentFilter[], triggerCharacters: string[], supportsResolveDetails: boolean): void {
-		this._registrations[handle] = modes.CompletionProviderRegistry.register(selector, <modes.CompletionItemProvider>{
+		const provider: modes.CompletionItemProvider = {
 			triggerCharacters,
 			provideCompletionItems: (model: ITextModel, position: EditorPosition, context: modes.CompletionContext, token: CancellationToken): Promise<modes.CompletionList | undefined> => {
 				return this._proxy.$provideCompletionItems(handle, model.uri, position, context, token).then(result => {
 					if (!result) {
-						return result;
+						// {{SQL CARBON EDIT}} @todo anthonydresser required because of strict null checks
+						return undefined;
 					}
 					return {
-						suggestions: result.suggestions,
-						incomplete: result.incomplete,
-						dispose: () => {
-							if (typeof result._id === 'number') {
-								this._proxy.$releaseCompletionItems(handle, result._id);
-							}
-						}
+						suggestions: result.b.map(d => MainThreadLanguageFeatures._inflateSuggestDto(result.a, d)),
+						incomplete: result.c,
+						dispose: () => this._proxy.$releaseCompletionItems(handle, result.x)
 					};
 				});
-			},
-			resolveCompletionItem: supportsResolveDetails
-				? (model, position, suggestion, token) => this._proxy.$resolveCompletionItem(handle, model.uri, position, suggestion, token)
-				: undefined
-		});
+			}
+		};
+		if (supportsResolveDetails) {
+			provider.resolveCompletionItem = (model, position, suggestion, token) => {
+				return this._proxy.$resolveCompletionItem(handle, model.uri, position, suggestion._id, suggestion._pid, token).then(result => {
+					if (!result) {
+						return suggestion;
+					}
+					let newSuggestion = MainThreadLanguageFeatures._inflateSuggestDto(suggestion.range, result);
+					return mixin(suggestion, newSuggestion, true);
+				});
+			};
+		}
+		this._registrations[handle] = modes.CompletionProviderRegistry.register(selector, provider);
 	}
 
 	// --- parameter hints

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

@@ -220,7 +220,7 @@ CommandsRegistry.registerCommand('_workbench.enterWorkspace', async function (ac
 		const runningExtensions = await extensionService.getExtensions();
 		// If requested extension to disable is running, then reload window with given workspace
 		if (disableExtensions && runningExtensions.some(runningExtension => disableExtensions.some(id => ExtensionIdentifier.equals(runningExtension.identifier, id)))) {
-			return windowService.openWindow([{ uri: workspace, typeHint: 'file' }], { args: { _: [], 'disable-extension': disableExtensions } });
+			return windowService.openWindow([{ workspaceUri: workspace }], { args: { _: [], 'disable-extension': disableExtensions } });
 		}
 	}