Merge from vscode aba87f135229c17c4624341b7a2499dcedafcb87 (#6430)

* Merge from vscode aba87f135229c17c4624341b7a2499dcedafcb87

* fix compile errors

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

@@ -8,7 +8,7 @@ import * as modes from 'vs/editor/common/modes';
 import { MainContext, MainThreadEditorInsetsShape, IExtHostContext, ExtHostEditorInsetsShape, ExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../common/extHostCustomers';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
-import { IWebviewService, Webview } from 'vs/workbench/contrib/webview/common/webview';
+import { IWebviewService, WebviewElement } from 'vs/workbench/contrib/webview/common/webview';
 import { DisposableStore } from 'vs/base/common/lifecycle';
 import { IActiveCodeEditor, IViewZone } from 'vs/editor/browser/editorBrowser';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
@@ -33,7 +33,7 @@ class EditorWebviewZone implements IViewZone {
 		readonly editor: IActiveCodeEditor,
 		readonly line: number,
 		readonly height: number,
-		readonly webview: Webview,
+		readonly webview: WebviewElement,
 	) {
 		this.domNode = document.createElement('div');
 		this.domNode.style.zIndex = '10'; // without this, the webview is not interactive
@@ -124,12 +124,11 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 	$setHtml(handle: number, value: string): void {
 		const inset = this.getInset(handle);
 		inset.webview.html = value;
-
 	}
 
 	$setOptions(handle: number, options: modes.IWebviewOptions): void {
 		const inset = this.getInset(handle);
-		inset.webview.options = options;
+		inset.webview.contentOptions = options;
 	}
 
 	async $postMessage(handle: number, value: any): Promise<boolean> {

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

@@ -308,10 +308,6 @@ export class MainThreadCommentController {
 		return commentingRanges || [];
 	}
 
-	getReactionGroup(): modes.CommentReaction[] | undefined {
-		return this._features.reactionGroup;
-	}
-
 	async toggleReaction(uri: URI, thread: modes.CommentThread, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
 		return this._proxy.$toggleReaction(this._handle, thread.commentThreadHandle, uri, comment, reaction);
 	}

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

@@ -9,7 +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 { IExtensionHostDebugService } from 'vs/workbench/services/extensions/common/extensionHostDebug';
+import { IExtensionHostDebugService } from 'vs/platform/debug/common/extensionHostDebug';
 
 @extHostNamedCustomer(MainContext.MainThreadConsole)
 export class MainThreadConsole implements MainThreadConsoleShape {

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

@@ -12,11 +12,12 @@ import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensio
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { localize } from 'vs/nls';
 import { Action } from 'vs/base/common/actions';
-import { EnablementState } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IWindowService } from 'vs/platform/windows/common/windows';
-import { IExtensionsWorkbenchService, IExtension } from 'vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionsWorkbenchService } from 'vs/workbench/contrib/extensions/common/extensions';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
 
 @extHostNamedCustomer(MainContext.MainThreadExtensionService)
 export class MainThreadExtensionService implements MainThreadExtensionServiceShape {
@@ -25,18 +26,21 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 	private readonly _notificationService: INotificationService;
 	private readonly _extensionsWorkbenchService: IExtensionsWorkbenchService;
 	private readonly _windowService: IWindowService;
+	private readonly _extensionEnablementService: IExtensionEnablementService;
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@IExtensionService extensionService: IExtensionService,
 		@INotificationService notificationService: INotificationService,
 		@IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService,
-		@IWindowService windowService: IWindowService
+		@IWindowService windowService: IWindowService,
+		@IExtensionEnablementService extensionEnablementService: IExtensionEnablementService
 	) {
 		this._extensionService = extensionService;
 		this._notificationService = notificationService;
 		this._extensionsWorkbenchService = extensionsWorkbenchService;
 		this._windowService = windowService;
+		this._extensionEnablementService = extensionEnablementService;
 	}
 
 	public dispose(): void {
@@ -74,30 +78,31 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 			const local = await this._extensionsWorkbenchService.queryLocal();
 			const installedDependency = local.filter(i => areSameExtensions(i.identifier, { id: missingDependency }))[0];
 			if (installedDependency) {
-				await this._handleMissingInstalledDependency(extension, installedDependency);
+				await this._handleMissingInstalledDependency(extension, installedDependency.local!);
 			} else {
 				await this._handleMissingNotInstalledDependency(extension, missingDependency);
 			}
 		}
 	}
 
-	private async _handleMissingInstalledDependency(extension: IExtensionDescription, missingInstalledDependency: IExtension): Promise<void> {
+	private async _handleMissingInstalledDependency(extension: IExtensionDescription, missingInstalledDependency: ILocalExtension): Promise<void> {
 		const extName = extension.displayName || extension.name;
-		if (missingInstalledDependency.enablementState === EnablementState.Enabled || missingInstalledDependency.enablementState === EnablementState.WorkspaceEnabled) {
+		if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
 			this._notificationService.notify({
 				severity: Severity.Error,
-				message: localize('reload window', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?", extName, missingInstalledDependency.displayName),
+				message: localize('reload window', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?", extName, missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name),
 				actions: {
 					primary: [new Action('reload', localize('reload', "Reload Window"), '', true, () => this._windowService.reloadWindow())]
 				}
 			});
 		} else {
+			const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
 			this._notificationService.notify({
 				severity: Severity.Error,
-				message: localize('disabledDep', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is disabled. Would you like to enable the extension and reload the window?", extName, missingInstalledDependency.displayName),
+				message: localize('disabledDep', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is disabled. Would you like to enable the extension and reload the window?", extName, missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name),
 				actions: {
 					primary: [new Action('enable', localize('enable dep', "Enable and Reload"), '', true,
-						() => this._extensionsWorkbenchService.setEnablement([missingInstalledDependency], missingInstalledDependency.enablementState === EnablementState.Disabled ? EnablementState.Enabled : EnablementState.WorkspaceEnabled)
+						() => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
 							.then(() => this._windowService.reloadWindow(), e => this._notificationService.error(e)))]
 				}
 			});

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

@@ -14,7 +14,6 @@ import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { ExtHostContext, ExtHostWebviewsShape, IExtHostContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelShowOptions } from 'vs/workbench/api/common/extHost.protocol';
 import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
-import { WebviewEditor } from 'vs/workbench/contrib/webview/browser/webviewEditor';
 import { WebviewEditorInput } from 'vs/workbench/contrib/webview/browser/webviewEditorInput';
 import { ICreateWebViewShowOptions, IWebviewEditorService, WebviewInputOptions } from 'vs/workbench/contrib/webview/browser/webviewEditorService';
 import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
@@ -22,8 +21,9 @@ import { ACTIVE_GROUP, IEditorService } from 'vs/workbench/services/editor/commo
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { extHostNamedCustomer } from '../common/extHostCustomers';
 import { IProductService } from 'vs/platform/product/common/product';
+import { startsWith } from 'vs/base/common/strings';
 
-interface MainThreadWebviewState {
+interface OldMainThreadWebviewState {
 	readonly viewType: string;
 	state: any;
 }
@@ -43,7 +43,7 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 
 
 	private readonly _proxy: ExtHostWebviewsShape;
-	private readonly _webviews = new Map<WebviewPanelHandle, WebviewEditorInput<MainThreadWebviewState>>();
+	private readonly _webviews = new Map<WebviewPanelHandle, WebviewEditorInput>();
 	private readonly _revivers = new Map<string, IDisposable>();
 
 	private _activeWebview: WebviewPanelHandle | undefined = undefined;
@@ -67,8 +67,12 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		// This reviver's only job is to activate webview extensions
 		// This should trigger the real reviver to be registered from the extension host side.
 		this._register(_webviewEditorService.registerReviver({
-			canRevive: (webview: WebviewEditorInput<any>) => {
-				const viewType = webview.state && webview.state.viewType;
+			canRevive: (webview: WebviewEditorInput) => {
+				if (!webview.webview.state) {
+					return false;
+				}
+
+				const viewType = this.fromInternalWebviewViewType(webview.viewType);
 				if (typeof viewType === 'string') {
 					extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
 				}
@@ -96,11 +100,8 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		const webview = this._webviewEditorService.createWebview(handle, this.getInternalWebviewViewType(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), {
 			location: URI.revive(extensionLocation),
 			id: extensionId
-		}, this.createWebviewEventDelegate(handle)) as WebviewEditorInput<MainThreadWebviewState>;
-		webview.state = {
-			viewType: viewType,
-			state: undefined
-		};
+		});
+		this.hookupWebviewEventDelegate(handle, webview);
 
 		this._webviews.set(handle, webview);
 
@@ -129,12 +130,12 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 
 	public $setHtml(handle: WebviewPanelHandle, value: string): void {
 		const webview = this.getWebview(handle);
-		webview.html = value;
+		webview.webview.html = value;
 	}
 
 	public $setOptions(handle: WebviewPanelHandle, options: modes.IWebviewOptions): void {
 		const webview = this.getWebview(handle);
-		webview.setOptions(reviveWebviewOptions(options as any /*todo@mat */));
+		webview.webview.contentOptions = reviveWebviewOptions(options as any /*todo@mat */);
 	}
 
 	public $reveal(handle: WebviewPanelHandle, showOptions: WebviewPanelShowOptions): void {
@@ -151,22 +152,8 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 
 	public async $postMessage(handle: WebviewPanelHandle, message: any): Promise<boolean> {
 		const webview = this.getWebview(handle);
-		const editors = this._editorService.visibleControls
-			.filter(e => e instanceof WebviewEditor)
-			.map(e => e as WebviewEditor)
-			.filter(e => e.input!.matches(webview));
-
-		if (editors.length > 0) {
-			editors[0].sendMessage(message);
-			return true;
-		}
-
-		if (webview.webview) {
-			webview.webview.sendMessage(message);
-			return true;
-		}
-
-		return false;
+		webview.webview.sendMessage(message);
+		return true;
 	}
 
 	public $registerSerializer(viewType: string): void {
@@ -175,28 +162,42 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		}
 
 		this._revivers.set(viewType, this._webviewEditorService.registerReviver({
-			canRevive: (webview) => {
-				return webview.state && webview.state.viewType === viewType;
+			canRevive: (webviewEditorInput) => {
+				return !!webviewEditorInput.webview.state && webviewEditorInput.viewType === this.getInternalWebviewViewType(viewType);
 			},
-			reviveWebview: async (webview): Promise<void> => {
-				const viewType = webview.state.viewType;
-				const handle = 'revival-' + MainThreadWebviews.revivalPool++;
-				this._webviews.set(handle, webview);
-				webview._events = this.createWebviewEventDelegate(handle);
+			reviveWebview: async (webviewEditorInput): Promise<void> => {
+				const viewType = this.fromInternalWebviewViewType(webviewEditorInput.viewType);
+				if (!viewType) {
+					webviewEditorInput.webview.html = MainThreadWebviews.getDeserializationFailedContents(webviewEditorInput.viewType);
+					return;
+				}
+
+				const handle = `revival-${MainThreadWebviews.revivalPool++}`;
+				this._webviews.set(handle, webviewEditorInput);
+				this.hookupWebviewEventDelegate(handle, webviewEditorInput);
 				let state = undefined;
-				if (webview.state.state) {
+				if (webviewEditorInput.webview.state) {
 					try {
-						state = JSON.parse(webview.state.state);
+						// Check for old-style webview state first which stored state inside another state object
+						// TODO: remove this after 1.37 ships.
+						if (
+							typeof (webviewEditorInput.webview.state as unknown as OldMainThreadWebviewState).viewType === 'string' &&
+							'state' in (webviewEditorInput.webview.state as unknown as OldMainThreadWebviewState)
+						) {
+							state = JSON.parse((webviewEditorInput.webview.state as any).state);
+						} else {
+							state = JSON.parse(webviewEditorInput.webview.state);
+						}
 					} catch {
 						// noop
 					}
 				}
 
 				try {
-					await this._proxy.$deserializeWebviewPanel(handle, viewType, webview.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webview.group || 0), webview.options);
+					await this._proxy.$deserializeWebviewPanel(handle, viewType, webviewEditorInput.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webviewEditorInput.group || 0), webviewEditorInput.webview.options);
 				} catch (error) {
 					onUnexpectedError(error);
-					webview.html = MainThreadWebviews.getDeserializationFailedContents(viewType);
+					webviewEditorInput.webview.html = MainThreadWebviews.getDeserializationFailedContents(viewType);
 				}
 			}
 		}));
@@ -216,23 +217,28 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		return `mainThreadWebview-${viewType}`;
 	}
 
-	private createWebviewEventDelegate(handle: WebviewPanelHandle) {
-		return {
-			onDidClickLink: (uri: URI) => this.onDidClickLink(handle, uri),
-			onMessage: (message: any) => this._proxy.$onMessage(handle, message),
-			onDispose: () => {
-				this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
-					this._webviews.delete(handle);
-				});
-			},
-			onDidUpdateWebviewState: (newState: any) => {
-				const webview = this.tryGetWebview(handle);
-				if (!webview || webview.isDisposed()) {
-					return;
-				}
-				(webview as WebviewEditorInput<MainThreadWebviewState>).state.state = newState;
+	private fromInternalWebviewViewType(viewType: string): string | undefined {
+		if (!startsWith(viewType, 'mainThreadWebview-')) {
+			return undefined;
+		}
+		return viewType.replace(/^mainThreadWebview-/, '');
+	}
+
+	private hookupWebviewEventDelegate(handle: WebviewPanelHandle, input: WebviewEditorInput) {
+		input.webview.onDidClickLink((uri: URI) => this.onDidClickLink(handle, uri));
+		input.webview.onMessage((message: any) => this._proxy.$onMessage(handle, message));
+		input.onDispose(() => {
+			this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
+				this._webviews.delete(handle);
+			});
+		});
+		input.webview.onDidUpdateState((newState: any) => {
+			const webview = this.tryGetWebview(handle);
+			if (!webview || webview.isDisposed()) {
+				return;
 			}
-		};
+			webview.webview.state = newState;
+		});
 	}
 
 	private onActiveEditorChanged() {
@@ -319,7 +325,7 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		if (this._productService.urlProtocol === link.scheme) {
 			return true;
 		}
-		return !!webview.options.enableCommandUris && link.scheme === 'command';
+		return !!webview.webview.contentOptions.enableCommandUris && link.scheme === 'command';
 	}
 
 	private getWebview(handle: WebviewPanelHandle): WebviewEditorInput {
@@ -347,13 +353,15 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 	}
 }
 
-function reviveWebviewOptions(options: WebviewInputOptions): WebviewInputOptions {
+function reviveWebviewOptions(options: modes.IWebviewOptions): WebviewInputOptions {
 	return {
 		...options,
+		allowScripts: options.enableScripts,
 		localResourceRoots: Array.isArray(options.localResourceRoots) ? options.localResourceRoots.map(r => URI.revive(r)) : undefined,
 	};
 }
 
+
 function reviveWebviewIcon(
 	value: { light: UriComponents, dark: UriComponents } | undefined
 ): { light: URI, dark: URI } | undefined {

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

@@ -1287,7 +1287,6 @@ export interface ExtHostCommentsShape {
 	$updateCommentThreadTemplate(commentControllerHandle: number, threadHandle: number, range: IRange): Promise<void>;
 	$deleteCommentThread(commentControllerHandle: number, commentThreadHandle: number): void;
 	$provideCommentingRanges(commentControllerHandle: number, uriComponents: UriComponents, token: CancellationToken): Promise<IRange[] | undefined>;
-	$provideReactionGroup(commentControllerHandle: number): Promise<modes.CommentReaction[] | undefined>;
 	$toggleReaction(commentControllerHandle: number, threadHandle: number, uri: UriComponents, comment: modes.Comment, reaction: modes.CommentReaction): Promise<void>;
 }
 

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

@@ -187,47 +187,28 @@ export class ExtHostComments implements ExtHostCommentsShape, IDisposable {
 		}).then(ranges => ranges ? ranges.map(x => extHostTypeConverter.Range.from(x)) : undefined);
 	}
 
-	$provideReactionGroup(commentControllerHandle: number): Promise<modes.CommentReaction[] | undefined> {
-		const commentController = this._commentControllers.get(commentControllerHandle);
-
-		if (!commentController || !commentController.reactionProvider) {
-			return Promise.resolve(undefined);
-		}
-
-		return asPromise(() => {
-			return commentController!.reactionProvider!.availableReactions;
-		}).then(reactions => reactions.map(reaction => convertToReaction(commentController.reactionProvider, reaction)));
-	}
-
 	$toggleReaction(commentControllerHandle: number, threadHandle: number, uri: UriComponents, comment: modes.Comment, reaction: modes.CommentReaction): Promise<void> {
-		const document = this._documents.getDocument(URI.revive(uri));
 		const commentController = this._commentControllers.get(commentControllerHandle);
 
-		if (!commentController || !((commentController.reactionProvider && commentController.reactionProvider.toggleReaction) || commentController.reactionHandler)) {
+		if (!commentController || !commentController.reactionHandler) {
 			return Promise.resolve(undefined);
 		}
 
 		return asPromise(() => {
 			const commentThread = commentController.getCommentThread(threadHandle);
 			if (commentThread) {
-				const vscodeComment = commentThread.getComment(comment.commentId);
+				const vscodeComment = commentThread.getCommentByUniqueId(comment.uniqueIdInThread);
 
 				if (commentController !== undefined && vscodeComment) {
 					if (commentController.reactionHandler) {
 						return commentController.reactionHandler(vscodeComment, convertFromReaction(reaction));
 					}
-
-					if (commentController.reactionProvider && commentController.reactionProvider.toggleReaction) {
-						return commentController.reactionProvider.toggleReaction(document, vscodeComment, convertFromReaction(reaction));
-					}
 				}
-
 			}
 
 			return Promise.resolve(undefined);
 		});
 	}
-
 	dispose() {
 
 	}
@@ -391,16 +372,6 @@ export class ExtHostCommentThread implements vscode.CommentThread {
 		);
 	}
 
-	getComment(commentId: string): vscode.Comment | undefined {
-		const comments = this._comments.filter(comment => comment.commentId === commentId);
-
-		if (comments && comments.length) {
-			return comments[0];
-		}
-
-		return undefined;
-	}
-
 	getCommentByUniqueId(uniqueId: number): vscode.Comment | undefined {
 		for (let key of this._commentsMap) {
 			let comment = key[0];
@@ -442,19 +413,6 @@ class ExtHostCommentController implements vscode.CommentController {
 	private _threads: Map<number, ExtHostCommentThread> = new Map<number, ExtHostCommentThread>();
 	commentingRangeProvider?: vscode.CommentingRangeProvider;
 
-	private _commentReactionProvider?: vscode.CommentReactionProvider;
-
-	get reactionProvider(): vscode.CommentReactionProvider | undefined {
-		return this._commentReactionProvider;
-	}
-
-	set reactionProvider(provider: vscode.CommentReactionProvider | undefined) {
-		this._commentReactionProvider = provider;
-		if (provider) {
-			this._proxy.$updateCommentControllerFeatures(this.handle, { reactionGroup: provider.availableReactions.map(reaction => convertToReaction(provider, reaction)) });
-		}
-	}
-
 	private _reactionHandler?: ReactionHandler;
 
 	get reactionHandler(): ReactionHandler | undefined {
@@ -537,7 +495,6 @@ function convertToModeComment(thread: ExtHostCommentThread, commentController: E
 	const iconPath = vscodeComment.author && vscodeComment.author.iconPath ? vscodeComment.author.iconPath.toString() : undefined;
 
 	return {
-		commentId: vscodeComment.commentId,
 		mode: vscodeComment.mode,
 		contextValue: vscodeComment.contextValue,
 		uniqueIdInThread: commentUniqueId,
@@ -545,17 +502,16 @@ function convertToModeComment(thread: ExtHostCommentThread, commentController: E
 		userName: vscodeComment.author.name,
 		userIconPath: iconPath,
 		label: vscodeComment.label,
-		commentReactions: vscodeComment.reactions ? vscodeComment.reactions.map(reaction => convertToReaction(commentController.reactionProvider, reaction)) : undefined
+		commentReactions: vscodeComment.reactions ? vscodeComment.reactions.map(reaction => convertToReaction(reaction)) : undefined
 	};
 }
 
-function convertToReaction(provider: vscode.CommentReactionProvider | undefined, reaction: vscode.CommentReaction): modes.CommentReaction {
+function convertToReaction(reaction: vscode.CommentReaction): modes.CommentReaction {
 	return {
 		label: reaction.label,
 		iconPath: reaction.iconPath ? extHostTypeConverter.pathOrURIToURI(reaction.iconPath) : undefined,
 		count: reaction.count,
-		hasReacted: reaction.hasReacted,
-		canEdit: provider !== undefined ? !!provider.toggleReaction : false
+		hasReacted: reaction.authorHasReacted,
 	};
 }
 
@@ -564,7 +520,6 @@ function convertFromReaction(reaction: modes.CommentReaction): vscode.CommentRea
 		label: reaction.label || '',
 		count: reaction.count || 0,
 		iconPath: reaction.iconPath ? URI.revive(reaction.iconPath) : '',
-		hasReacted: reaction.hasReacted,
 		authorHasReacted: reaction.hasReacted || false
 	};
 }

src/vs/workbench/api/node/extHostCLIServer.ts

@@ -18,6 +18,7 @@ export interface OpenCommandPipeArgs {
 	forceNewWindow?: boolean;
 	diffMode?: boolean;
 	addMode?: boolean;
+	gotoLineMode?: boolean;
 	forceReuseWindow?: boolean;
 	waitMarkerFilePath?: string;
 }
@@ -93,7 +94,7 @@ export class CLIServer {
 	}
 
 	private open(data: OpenCommandPipeArgs, res: http.ServerResponse) {
-		let { fileURIs, folderURIs, forceNewWindow, diffMode, addMode, forceReuseWindow, waitMarkerFilePath } = data;
+		let { fileURIs, folderURIs, forceNewWindow, diffMode, addMode, forceReuseWindow, gotoLineMode, waitMarkerFilePath } = data;
 		const urisToOpen: IURIToOpen[] = [];
 		if (Array.isArray(folderURIs)) {
 			for (const s of folderURIs) {
@@ -125,7 +126,7 @@ export class CLIServer {
 		}
 		if (urisToOpen.length) {
 			const waitMarkerFileURI = waitMarkerFilePath ? URI.file(waitMarkerFilePath) : undefined;
-			const windowOpenArgs: IOpenSettings = { forceNewWindow, diffMode, addMode, forceReuseWindow, waitMarkerFileURI };
+			const windowOpenArgs: IOpenSettings = { forceNewWindow, diffMode, addMode, gotoLineMode, forceReuseWindow, waitMarkerFileURI };
 			this._commands.executeCommand('_files.windowOpen', urisToOpen, windowOpenArgs);
 		}
 		res.writeHead(200);

src/vs/workbench/api/node/extHostRequireInterceptor.ts

@@ -231,23 +231,19 @@ export class OpenNodeModuleFactory implements INodeModuleFactory {
 		if (!this._extensionId) {
 			return;
 		}
-		/* __GDPR__
-			"shimming.open" : {
-				"extension": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-			}
-		*/
-		this._mainThreadTelemerty.$publicLog('shimming.open', { extension: this._extensionId });
+		type ShimmingOpenClassification = {
+			extension: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+		};
+		this._mainThreadTelemerty.$publicLog2<{ extension: string }, ShimmingOpenClassification>('shimming.open', { extension: this._extensionId });
 	}
 
 	private sendNoForwardTelemetry(): void {
 		if (!this._extensionId) {
 			return;
 		}
-		/* __GDPR__
-			"shimming.open.call.noForward" : {
-				"extension": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-			}
-		*/
-		this._mainThreadTelemerty.$publicLog('shimming.open.call.noForward', { extension: this._extensionId });
+		type ShimmingOpenCallNoForwardClassification = {
+			extension: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+		};
+		this._mainThreadTelemerty.$publicLog2<{ extension: string }, ShimmingOpenCallNoForwardClassification>('shimming.open.call.noForward', { extension: this._extensionId });
 	}
 }