Merge from vscode 6e530127a1bb8ffbd1bfb77dc680c321dc0d71f5 (#6844)

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, WebviewElement } from 'vs/workbench/contrib/webview/common/webview';
+import { IWebviewService, WebviewElement } from 'vs/workbench/contrib/webview/browser/webview';
 import { DisposableStore } from 'vs/base/common/lifecycle';
 import { IActiveCodeEditor, IViewZone } from 'vs/editor/browser/editorBrowser';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

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

@@ -5,24 +5,43 @@
 
 import { IMarkerService, IMarkerData } from 'vs/platform/markers/common/markers';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { MainThreadDiagnosticsShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { MainThreadDiagnosticsShape, MainContext, IExtHostContext, ExtHostDiagnosticsShape, ExtHostContext } from '../common/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 @extHostNamedCustomer(MainContext.MainThreadDiagnostics)
 export class MainThreadDiagnostics implements MainThreadDiagnosticsShape {
 
 	private readonly _activeOwners = new Set<string>();
+
+	private readonly _proxy: ExtHostDiagnosticsShape;
 	private readonly _markerService: IMarkerService;
+	private readonly _markerListener: IDisposable;
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@IMarkerService markerService: IMarkerService
 	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDiagnostics);
 		this._markerService = markerService;
+		this._markerListener = this._markerService.onMarkerChanged(this._forwardMarkers, this);
 	}
 
 	dispose(): void {
+		this._markerListener.dispose();
 		this._activeOwners.forEach(owner => this._markerService.changeAll(owner, []));
+		this._activeOwners.clear();
+	}
+
+	private _forwardMarkers(resources: URI[]): void {
+		const data: [UriComponents, IMarkerData[]][] = [];
+		for (const resource of resources) {
+			data.push([
+				resource,
+				this._markerService.read({ resource }).filter(marker => !this._activeOwners.has(marker.owner))
+			]);
+		}
+		this._proxy.$acceptMarkersChange(data);
 	}
 
 	$changeMany(owner: string, entries: [UriComponents, IMarkerData[]][]): void {

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

@@ -11,6 +11,7 @@ import { distinct } from 'vs/base/common/arrays';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { isUndefinedOrNull, isNumber } from 'vs/base/common/types';
 import { Registry } from 'vs/platform/registry/common/platform';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 
 @extHostNamedCustomer(MainContext.MainThreadTreeViews)
 export class MainThreadTreeViews extends Disposable implements MainThreadTreeViewsShape {
@@ -21,25 +22,28 @@ export class MainThreadTreeViews extends Disposable implements MainThreadTreeVie
 	constructor(
 		extHostContext: IExtHostContext,
 		@IViewsService private readonly viewsService: IViewsService,
-		@INotificationService private readonly notificationService: INotificationService
+		@INotificationService private readonly notificationService: INotificationService,
+		@IExtensionService private readonly extensionService: IExtensionService
 	) {
 		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTreeViews);
 	}
 
 	$registerTreeViewDataProvider(treeViewId: string, options: { showCollapseAll: boolean, canSelectMany: boolean }): void {
-		const dataProvider = new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService);
-		this._dataProviders.set(treeViewId, dataProvider);
-		const viewer = this.getTreeView(treeViewId);
-		if (viewer) {
-			viewer.dataProvider = dataProvider;
-			viewer.showCollapseAllAction = !!options.showCollapseAll;
-			viewer.canSelectMany = !!options.canSelectMany;
-			this.registerListeners(treeViewId, viewer);
-			this._proxy.$setVisible(treeViewId, viewer.visible);
-		} else {
-			this.notificationService.error('No view is registered with id: ' + treeViewId);
-		}
+		this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+			const dataProvider = new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService);
+			this._dataProviders.set(treeViewId, dataProvider);
+			const viewer = this.getTreeView(treeViewId);
+			if (viewer) {
+				viewer.dataProvider = dataProvider;
+				viewer.showCollapseAllAction = !!options.showCollapseAll;
+				viewer.canSelectMany = !!options.canSelectMany;
+				this.registerListeners(treeViewId, viewer);
+				this._proxy.$setVisible(treeViewId, viewer.visible);
+			} else {
+				this.notificationService.error('No view is registered with id: ' + treeViewId);
+			}
+		});
 	}
 
 	$reveal(treeViewId: string, item: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Promise<void> {

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

@@ -5,30 +5,62 @@
 
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
-import * as map from 'vs/base/common/map';
+import { startsWith } from 'vs/base/common/strings';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import * as modes from 'vs/editor/common/modes';
 import { localize } from 'vs/nls';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
+import { IProductService } from 'vs/platform/product/common/product';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { ExtHostContext, ExtHostWebviewsShape, IExtHostContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelShowOptions } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostContext, ExtHostWebviewsShape, IExtHostContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelShowOptions, WebviewPanelViewStateData } from 'vs/workbench/api/common/extHost.protocol';
 import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
+import { Webview } from 'vs/workbench/contrib/webview/browser/webview';
 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';
-import { ACTIVE_GROUP, IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 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';
-import { Webview } from 'vs/workbench/contrib/webview/common/webview';
 
 interface OldMainThreadWebviewState {
 	readonly viewType: string;
 	state: any;
 }
 
+/**
+ * Bi-directional map between webview handles and inputs.
+ */
+class WebviewHandleStore {
+	private readonly _handlesToInputs = new Map<string, WebviewEditorInput>();
+	private readonly _inputsToHandles = new Map<WebviewEditorInput, string>();
+
+	public add(handle: string, input: WebviewEditorInput): void {
+		this._handlesToInputs.set(handle, input);
+		this._inputsToHandles.set(input, handle);
+	}
+
+	public getHandleForInput(input: WebviewEditorInput): string | undefined {
+		return this._inputsToHandles.get(input);
+	}
+
+	public getInputForHandle(handle: string): WebviewEditorInput | undefined {
+		return this._handlesToInputs.get(handle);
+	}
+
+	public delete(handle: string): void {
+		const input = this.getInputForHandle(handle);
+		this._handlesToInputs.delete(handle);
+		if (input) {
+			this._inputsToHandles.delete(input);
+		}
+	}
+
+	public get size(): number {
+		return this._handlesToInputs.size;
+	}
+}
+
 @extHostNamedCustomer(MainContext.MainThreadWebviews)
 export class MainThreadWebviews extends Disposable implements MainThreadWebviewsShape {
 
@@ -43,12 +75,9 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 	private static revivalPool = 0;
 
 	private readonly _proxy: ExtHostWebviewsShape;
-	private readonly _webviewEditorInputs = new Map<string, WebviewEditorInput>();
-	private readonly _webviews = new Map<string, Webview>();
+	private readonly _webviewEditorInputs = new WebviewHandleStore();
 	private readonly _revivers = new Map<string, IDisposable>();
 
-	private _activeWebview: WebviewPanelHandle | undefined = undefined;
-
 	constructor(
 		context: IExtHostContext,
 		@IExtensionService extensionService: IExtensionService,
@@ -62,8 +91,8 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		super();
 
 		this._proxy = context.getProxy(ExtHostContext.ExtHostWebviews);
-		this._register(_editorService.onDidActiveEditorChange(this.onActiveEditorChanged, this));
-		this._register(_editorService.onDidVisibleEditorsChange(this.onVisibleEditorsChanged, this));
+		this._register(_editorService.onDidActiveEditorChange(this.updateWebviewViewStates, this));
+		this._register(_editorService.onDidVisibleEditorsChange(this.updateWebviewViewStates, this));
 
 		// This reviver's only job is to activate webview extensions
 		// This should trigger the real reviver to be registered from the extension host side.
@@ -104,8 +133,7 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		});
 		this.hookupWebviewEventDelegate(handle, webview);
 
-		this._webviewEditorInputs.set(handle, webview);
-		this._webviews.set(handle, webview.webview);
+		this._webviewEditorInputs.add(handle, webview);
 
 		/* __GDPR__
 			"webviews:createWebviewPanel" : {
@@ -175,8 +203,7 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 				}
 
 				const handle = `revival-${MainThreadWebviews.revivalPool++}`;
-				this._webviewEditorInputs.set(handle, webviewEditorInput);
-				this._webviews.set(handle, webviewEditorInput.webview);
+				this._webviewEditorInputs.add(handle, webviewEditorInput);
 				this.hookupWebviewEventDelegate(handle, webviewEditorInput);
 
 				let state = undefined;
@@ -234,7 +261,6 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		input.onDispose(() => {
 			this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
 				this._webviewEditorInputs.delete(handle);
-				this._webviews.delete(handle);
 			});
 		});
 		input.webview.onDidUpdateState((newState: any) => {
@@ -246,70 +272,35 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		});
 	}
 
-	private onActiveEditorChanged() {
-		const activeEditor = this._editorService.activeControl;
-		let newActiveWebview: { input: WebviewEditorInput, handle: WebviewPanelHandle } | undefined = undefined;
-		if (activeEditor && activeEditor.input instanceof WebviewEditorInput) {
-			for (const handle of map.keys(this._webviewEditorInputs)) {
-				const input = this._webviewEditorInputs.get(handle)!;
-				if (input.matches(activeEditor.input)) {
-					newActiveWebview = { input, handle };
-					break;
-				}
-			}
-		}
-
-		if (newActiveWebview && newActiveWebview.handle === this._activeWebview) {
-			// Webview itself unchanged but position may have changed
-			this._proxy.$onDidChangeWebviewPanelViewState(newActiveWebview.handle, {
-				active: true,
-				visible: true,
-				position: editorGroupToViewColumn(this._editorGroupService, newActiveWebview.input.group || 0)
-			});
+	private updateWebviewViewStates() {
+		if (!this._webviewEditorInputs.size) {
 			return;
 		}
 
-		// Broadcast view state update for currently active
-		if (typeof this._activeWebview !== 'undefined') {
-			const oldActiveWebview = this._webviewEditorInputs.get(this._activeWebview);
-			if (oldActiveWebview) {
-				this._proxy.$onDidChangeWebviewPanelViewState(this._activeWebview, {
-					active: false,
-					visible: this._editorService.visibleControls.some(editor => !!editor.input && editor.input.matches(oldActiveWebview)),
-					position: editorGroupToViewColumn(this._editorGroupService, oldActiveWebview.group || 0),
-				});
-			}
-		}
+		const activeInput = this._editorService.activeControl && this._editorService.activeControl.input;
+		const viewStates: WebviewPanelViewStateData = {};
+		for (const group of this._editorGroupService.groups) {
+			for (const input of group.editors) {
+				if (!(input instanceof WebviewEditorInput)) {
+					continue;
+				}
 
-		// Then for newly active
-		if (newActiveWebview) {
-			this._proxy.$onDidChangeWebviewPanelViewState(newActiveWebview.handle, {
-				active: true,
-				visible: true,
-				position: editorGroupToViewColumn(this._editorGroupService, activeEditor ? activeEditor.group : ACTIVE_GROUP),
-			});
-			this._activeWebview = newActiveWebview.handle;
-		} else {
-			this._activeWebview = undefined;
-		}
-	}
+				input.updateGroup(group.id);
 
-	private onVisibleEditorsChanged(): void {
-		this._webviewEditorInputs.forEach((input, handle) => {
-			for (const workbenchEditor of this._editorService.visibleControls) {
-				if (workbenchEditor.input && workbenchEditor.input.matches(input)) {
-					const editorPosition = editorGroupToViewColumn(this._editorGroupService, workbenchEditor.group!);
-
-					input.updateGroup(workbenchEditor.group!.id);
-					this._proxy.$onDidChangeWebviewPanelViewState(handle, {
-						active: handle === this._activeWebview,
-						visible: true,
-						position: editorPosition
-					});
-					break;
+				const handle = this._webviewEditorInputs.getHandleForInput(input);
+				if (handle) {
+					viewStates[handle] = {
+						visible: input === group.activeEditor,
+						active: input === activeInput,
+						position: editorGroupToViewColumn(this._editorGroupService, group.id || 0),
+					};
 				}
 			}
-		});
+		}
+
+		if (Object.keys(viewStates).length) {
+			this._proxy.$onDidChangeWebviewPanelViewStates(viewStates);
+		}
 	}
 
 	private onDidClickLink(handle: WebviewPanelHandle, link: URI): void {
@@ -342,28 +333,19 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 	}
 
 	private tryGetWebviewEditorInput(handle: WebviewPanelHandle): WebviewEditorInput | undefined {
-		return this._webviewEditorInputs.get(handle);
+		return this._webviewEditorInputs.getInputForHandle(handle);
 	}
 
 	private getWebview(handle: WebviewPanelHandle): Webview {
-		const webview = this.tryGetWebview(handle);
-		if (!webview) {
-			throw new Error('Unknown webview handle:' + handle);
-		}
-		return webview;
-	}
-
-	private tryGetWebview(handle: WebviewPanelHandle): Webview | undefined {
-		return this._webviews.get(handle);
+		return this.getWebviewEditorInput(handle).webview;
 	}
 
 	private static getDeserializationFailedContents(viewType: string) {
 		return `<!DOCTYPE html>
 		<html>
 			<head>
-				<base href="https://code.visualstudio.com/raw/">
 				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
-				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src https: data:; media-src https:; script-src 'none'; style-src vscode-resource: https: 'unsafe-inline'; child-src 'none'; frame-src 'none';">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
 			<body>${localize('errorMessage', "An error occurred while restoring view:{0}", viewType)}</body>
 		</html>`;

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

@@ -59,7 +59,7 @@ export class MainThreadWindow implements MainThreadWindowShape {
 			}
 		}
 
-		return this.openerService.openExternal(uri);
+		return this.openerService.open(uri, { openExternal: true });
 	}
 
 	private getOrCreateTunnel(remotePort: number): Promise<RemoteTunnel> | undefined {

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

@@ -175,6 +175,11 @@ CommandsRegistry.registerCommand('_workbench.addToRecentlyOpened', async functio
 	return windowService.addRecentlyOpened([recent]);
 });
 
+CommandsRegistry.registerCommand('_workbench.getRecentlyOpened', async function (accessor: ServicesAccessor) {
+	const windowService = accessor.get(IWindowService);
+	return windowService.getRecentlyOpened();
+});
+
 export class SetEditorLayoutAPICommand {
 	public static ID = 'vscode.setEditorLayout';
 	public static execute(executor: ICommandsExecutor, layout: EditorGroupLayout): Promise<any> {
@@ -205,4 +210,4 @@ CommandsRegistry.registerCommand({
 			}
 		}]
 	}
-});
+});

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

@@ -39,13 +39,14 @@ const configurationEntrySchema: IJSONSchema = {
 							},
 							scope: {
 								type: 'string',
-								enum: ['application', 'machine', 'window', 'resource'],
+								enum: ['application', 'machine', 'window', 'resource', 'machine-overridable'],
 								default: 'window',
 								enumDescriptions: [
-									nls.localize('scope.application.description', "Application specific configuration, which can be configured only in the user settings."),
-									nls.localize('scope.machine.description', "Machine specific configuration, which can be configured only in the user settings when the extension is running locally, or only in the remote settings when the extension is running remotely."),
-									nls.localize('scope.window.description', "Window specific configuration, which can be configured in the user, remote or workspace settings."),
-									nls.localize('scope.resource.description', "Resource specific configuration, which can be configured in the user, remote, workspace or folder settings.")
+									nls.localize('scope.application.description', "Configuration that can be configured only in the user settings."),
+									nls.localize('scope.machine.description', "Configuration that can be configured only in the user settings when the extension is running locally, or only in the remote settings when the extension is running remotely."),
+									nls.localize('scope.window.description', "Configuration that can be configured in the user, remote or workspace settings."),
+									nls.localize('scope.resource.description', "Configuration that can be configured in the user, remote, workspace or folder settings."),
+									nls.localize('scope.machine-overridable.description', "Machine configuration that can be configured also in workspace or folder settings.")
 								],
 								description: nls.localize('scope.description', "Scope in which the configuration is applicable. Available scopes are `application`, `machine`, `window` and `resource`.")
 							},
@@ -215,6 +216,8 @@ function validateProperties(configuration: IConfigurationNode, extension: IExten
 					propertyConfiguration.scope = ConfigurationScope.MACHINE;
 				} else if (propertyConfiguration.scope.toString() === 'resource') {
 					propertyConfiguration.scope = ConfigurationScope.RESOURCE;
+				} else if (propertyConfiguration.scope.toString() === 'machine-overridable') {
+					propertyConfiguration.scope = ConfigurationScope.MACHINE_OVERRIDABLE;
 				} else {
 					propertyConfiguration.scope = ConfigurationScope.WINDOW;
 				}

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

@@ -553,15 +553,17 @@ export interface MainThreadWebviewsShape extends IDisposable {
 	$unregisterSerializer(viewType: string): void;
 }
 
-export interface WebviewPanelViewState {
-	readonly active: boolean;
-	readonly visible: boolean;
-	readonly position: EditorViewColumn;
+export interface WebviewPanelViewStateData {
+	[handle: string]: {
+		readonly active: boolean;
+		readonly visible: boolean;
+		readonly position: EditorViewColumn;
+	};
 }
 
 export interface ExtHostWebviewsShape {
 	$onMessage(handle: WebviewPanelHandle, message: any): void;
-	$onDidChangeWebviewPanelViewState(handle: WebviewPanelHandle, newState: WebviewPanelViewState): void;
+	$onDidChangeWebviewPanelViewStates(newState: WebviewPanelViewStateData): void;
 	$onDidDisposeWebviewPanel(handle: WebviewPanelHandle): Promise<void>;
 	$deserializeWebviewPanel(newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, state: any, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
 }
@@ -745,7 +747,7 @@ export interface ExtHostConfigurationShape {
 }
 
 export interface ExtHostDiagnosticsShape {
-
+	$acceptMarkersChange(data: [UriComponents, IMarkerData[]][]): void;
 }
 
 export interface ExtHostDocumentContentProvidersShape {

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

@@ -10,7 +10,7 @@ import { ExtHostTextEditor } from 'vs/workbench/api/common/extHostTextEditor';
 import { ExtHostEditors } from 'vs/workbench/api/common/extHostTextEditors';
 import * as vscode from 'vscode';
 import { ExtHostEditorInsetsShape, MainThreadEditorInsetsShape } from './extHost.protocol';
-import { toWebviewResource, WebviewInitData } from 'vs/workbench/api/common/shared/webview';
+import { asWebviewUri, WebviewInitData } from 'vs/workbench/api/common/shared/webview';
 import { generateUuid } from 'vs/base/common/uuid';
 
 export class ExtHostEditorInsets implements ExtHostEditorInsetsShape {
@@ -65,8 +65,8 @@ export class ExtHostEditorInsets implements ExtHostEditorInsetsShape {
 			private _html: string = '';
 			private _options: vscode.WebviewOptions = Object.create(null);
 
-			toWebviewResource(resource: vscode.Uri): vscode.Uri {
-				return toWebviewResource(that._initData, this._uuid, resource);
+			asWebviewUri(resource: vscode.Uri): vscode.Uri {
+				return asWebviewUri(that._initData, this._uuid, resource);
 			}
 
 			get cspSource(): string {

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

@@ -5,7 +5,7 @@
 
 import { localize } from 'vs/nls';
 import { IMarkerData, MarkerSeverity } from 'vs/platform/markers/common/markers';
-import { URI } from 'vs/base/common/uri';
+import { URI, UriComponents } from 'vs/base/common/uri';
 import * as vscode from 'vscode';
 import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape, IMainContext } from './extHost.protocol';
 import { DiagnosticSeverity } from './extHostTypes';
@@ -20,12 +20,12 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 	private readonly _owner: string;
 	private readonly _maxDiagnosticsPerFile: number;
 	private readonly _onDidChangeDiagnostics: Emitter<(vscode.Uri | string)[]>;
-	private readonly _proxy: MainThreadDiagnosticsShape;
+	private readonly _proxy: MainThreadDiagnosticsShape | undefined;
 
 	private _isDisposed = false;
 	private _data = new Map<string, vscode.Diagnostic[]>();
 
-	constructor(name: string, owner: string, maxDiagnosticsPerFile: number, proxy: MainThreadDiagnosticsShape, onDidChangeDiagnostics: Emitter<(vscode.Uri | string)[]>) {
+	constructor(name: string, owner: string, maxDiagnosticsPerFile: number, proxy: MainThreadDiagnosticsShape | undefined, onDidChangeDiagnostics: Emitter<(vscode.Uri | string)[]>) {
 		this._name = name;
 		this._owner = owner;
 		this._maxDiagnosticsPerFile = maxDiagnosticsPerFile;
@@ -36,7 +36,9 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 	dispose(): void {
 		if (!this._isDisposed) {
 			this._onDidChangeDiagnostics.fire(keys(this._data));
-			this._proxy.$clear(this._owner);
+			if (this._proxy) {
+				this._proxy.$clear(this._owner);
+			}
 			this._data = undefined!;
 			this._isDisposed = true;
 		}
@@ -112,6 +114,9 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 		this._onDidChangeDiagnostics.fire(toSync);
 
 		// compute change and send to main side
+		if (!this._proxy) {
+			return;
+		}
 		const entries: [URI, IMarkerData[]][] = [];
 		for (let uri of toSync) {
 			let marker: IMarkerData[] = [];
@@ -149,7 +154,6 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 
 			entries.push([uri, marker]);
 		}
-
 		this._proxy.$changeMany(this._owner, entries);
 	}
 
@@ -157,14 +161,18 @@ export class DiagnosticCollection implements vscode.DiagnosticCollection {
 		this._checkDisposed();
 		this._onDidChangeDiagnostics.fire([uri]);
 		this._data.delete(uri.toString());
-		this._proxy.$changeMany(this._owner, [[uri, undefined]]);
+		if (this._proxy) {
+			this._proxy.$changeMany(this._owner, [[uri, undefined]]);
+		}
 	}
 
 	clear(): void {
 		this._checkDisposed();
 		this._onDidChangeDiagnostics.fire(keys(this._data));
 		this._data.clear();
-		this._proxy.$clear(this._owner);
+		if (this._proxy) {
+			this._proxy.$clear(this._owner);
+		}
 	}
 
 	forEach(callback: (uri: URI, diagnostics: ReadonlyArray<vscode.Diagnostic>, collection: DiagnosticCollection) => any, thisArg?: any): void {
@@ -311,4 +319,20 @@ export class ExtHostDiagnostics implements ExtHostDiagnosticsShape {
 		});
 		return res;
 	}
+
+	private _mirrorCollection: vscode.DiagnosticCollection | undefined;
+
+	$acceptMarkersChange(data: [UriComponents, IMarkerData[]][]): void {
+
+		if (!this._mirrorCollection) {
+			const name = '_generated_mirror';
+			const collection = new DiagnosticCollection(name, name, ExtHostDiagnostics._maxDiagnosticsPerFile, undefined, this._onDidChangeDiagnostics);
+			this._collections.set(name, collection);
+			this._mirrorCollection = collection;
+		}
+
+		for (const [uri, markers] of data) {
+			this._mirrorCollection.set(URI.revive(uri), markers.map(converter.Diagnostic.to));
+		}
+	}
 }

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

@@ -24,12 +24,12 @@ import { IExtensionApiFactory as sqlIApiFactory } from 'sql/workbench/api/common
 
 
 interface LoadFunction {
-	(request: string, parent: { filename: string; }, isMain: any): any;
+	(request: string): any;
 }
 
 export interface INodeModuleFactory { //{{SQL CARBON EDIT}} export interface
 	readonly nodeModuleName: string | string[];
-	load(request: string, parent: URI, isMain: any, original: LoadFunction): any;
+	load(request: string, parent: URI, original: LoadFunction): any;
 	alternativeModuleName?(name: string): string | undefined;
 }
 
@@ -250,7 +250,7 @@ class OpenNodeModuleFactory implements INodeModuleFactory {
 		};
 	}
 
-	public load(request: string, parent: URI, isMain: any, original: LoadFunction): any {
+	public load(request: string, parent: URI, original: LoadFunction): any {
 		// get extension id from filename and api for extension
 		const extension = this._extensionPaths.findSubstr(parent.fsPath);
 		if (extension) {
@@ -258,7 +258,7 @@ class OpenNodeModuleFactory implements INodeModuleFactory {
 			this.sendShimmingTelemetry();
 		}
 
-		this._original = original(request, { filename: parent.fsPath }, isMain);
+		this._original = original(request);
 		return this._impl;
 	}
 

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

@@ -113,6 +113,15 @@ export namespace DiagnosticTag {
 		}
 		return undefined;
 	}
+	export function to(value: MarkerTag): vscode.DiagnosticTag | undefined {
+		switch (value) {
+			case MarkerTag.Unnecessary:
+				return types.DiagnosticTag.Unnecessary;
+			case MarkerTag.Deprecated:
+				return types.DiagnosticTag.Deprecated;
+		}
+		return undefined;
+	}
 }
 
 export namespace Diagnostic {
@@ -127,6 +136,15 @@ export namespace Diagnostic {
 			tags: Array.isArray(value.tags) ? coalesce(value.tags.map(DiagnosticTag.from)) : undefined,
 		};
 	}
+
+	export function to(value: IMarkerData): vscode.Diagnostic {
+		const res = new types.Diagnostic(Range.to(value), value.message, DiagnosticSeverity.to(value.severity));
+		res.source = value.source;
+		res.code = value.code;
+		res.relatedInformation = value.relatedInformation && value.relatedInformation.map(DiagnosticRelatedInformation.to);
+		res.tags = value.tags && coalesce(value.tags.map(DiagnosticTag.to));
+		return res;
+	}
 }
 
 export namespace DiagnosticRelatedInformation {

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

@@ -5,15 +5,15 @@
 
 import { Emitter, Event } from 'vs/base/common/event';
 import { URI } from 'vs/base/common/uri';
+import { generateUuid } from 'vs/base/common/uuid';
+import * as modes from 'vs/editor/common/modes';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
 import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';
+import { asWebviewUri, WebviewInitData } from 'vs/workbench/api/common/shared/webview';
 import * as vscode from 'vscode';
-import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelViewState } from './extHost.protocol';
+import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelViewStateData } from './extHost.protocol';
 import { Disposable } from './extHostTypes';
-import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
-import * as modes from 'vs/editor/common/modes';
-import { WebviewInitData, toWebviewResource } from 'vs/workbench/api/common/shared/webview';
-import { generateUuid } from 'vs/base/common/uuid';
 
 type IconPath = URI | { light: URI, dark: URI };
 
@@ -35,8 +35,8 @@ export class ExtHostWebview implements vscode.Webview {
 		this._onMessageEmitter.dispose();
 	}
 
-	public toWebviewResource(resource: vscode.Uri): vscode.Uri {
-		return toWebviewResource(this._initData, this._handle, resource);
+	public asWebviewUri(resource: vscode.Uri): vscode.Uri {
+		return asWebviewUri(this._initData, this._handle, resource);
 	}
 
 	public get cspSource(): string {
@@ -89,11 +89,12 @@ export class ExtHostWebviewPanel implements vscode.WebviewPanel {
 
 	private readonly _options: vscode.WebviewPanelOptions;
 	private readonly _webview: ExtHostWebview;
-	private _isDisposed: boolean = false;
 	private _viewColumn: vscode.ViewColumn | undefined;
 	private _visible: boolean = true;
 	private _active: boolean = true;
 
+	_isDisposed: boolean = false;
+
 	readonly _onDisposeEmitter = new Emitter<void>();
 	public readonly onDidDispose: Event<void> = this._onDisposeEmitter.event;
 
@@ -297,21 +298,21 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		}
 	}
 
-	public $onDidChangeWebviewPanelViewState(
-		handle: WebviewPanelHandle,
-		newState: WebviewPanelViewState
-	): void {
-		const panel = this.getWebviewPanel(handle);
-		if (!panel) {
-			return;
-		}
+	public $onDidChangeWebviewPanelViewStates(newStates: WebviewPanelViewStateData): void {
+		for (const handle of Object.keys(newStates)) {
+			const panel = this.getWebviewPanel(handle);
+			if (!panel || panel._isDisposed) {
+				continue;
+			}
 
-		const viewColumn = typeConverters.ViewColumn.to(newState.position);
-		if (panel.active !== newState.active || panel.visible !== newState.visible || panel.viewColumn !== viewColumn) {
-			panel._setActive(newState.active);
-			panel._setVisible(newState.visible);
-			panel._setViewColumn(viewColumn);
-			panel._onDidChangeViewStateEmitter.fire({ webviewPanel: panel });
+			const newState = newStates[handle];
+			const viewColumn = typeConverters.ViewColumn.to(newState.position);
+			if (panel.active !== newState.active || panel.visible !== newState.visible || panel.viewColumn !== viewColumn) {
+				panel._setActive(newState.active);
+				panel._setVisible(newState.visible);
+				panel._setViewColumn(viewColumn);
+				panel._onDidChangeViewStateEmitter.fire({ webviewPanel: panel });
+			}
 		}
 	}
 

src/vs/workbench/api/common/shared/webview.ts

@@ -11,7 +11,7 @@ export interface WebviewInitData {
 	readonly webviewCspSource: string;
 }
 
-export function toWebviewResource(
+export function asWebviewUri(
 	initData: WebviewInitData,
 	uuid: string,
 	resource: vscode.Uri

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

@@ -31,7 +31,11 @@ class NodeModuleRequireInterceptor extends RequireInterceptor {
 			if (!that._factories.has(request)) {
 				return original.apply(this, arguments);
 			}
-			return that._factories.get(request)!.load(request, URI.file(parent.filename), isMain, original);
+			return that._factories.get(request)!.load(
+				request,
+				URI.file(parent.filename),
+				request => original.apply(this, [request, parent, isMain])
+			);
 		};
 	}
 }

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

@@ -497,6 +497,7 @@ export class ExtHostTerminalService implements IExtHostTerminalService, ExtHostT
 		const terminalConfig = configProvider.getConfiguration('terminal.integrated');
 
 		const initialCwd = terminalEnvironment.getCwd(shellLaunchConfig, os.homedir(), lastActiveWorkspace ? lastActiveWorkspace : undefined, this._variableResolver, activeWorkspaceRootUri, terminalConfig.cwd, this._logService);
+		shellLaunchConfig.cwd = initialCwd;
 
 		const envFromConfig = this._apiInspectConfigToPlain(configProvider.getConfiguration('terminal.integrated').inspect<ITerminalEnvironment>(`env.${platformKey}`));
 		const baseEnv = terminalConfig.get<boolean>('inheritEnv', true) ? process.env as platform.IProcessEnvironment : await this._getNonInheritedEnv();

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

@@ -89,7 +89,7 @@ class WorkerRequireInterceptor extends RequireInterceptor {
 		}
 
 		if (this._factories.has(request)) {
-			return this._factories.get(request)!.load(request, parent, false, () => { throw new Error(); });
+			return this._factories.get(request)!.load(request, parent, () => { throw new Error('CANNOT LOAD MODULE from here.'); });
 		}
 		return undefined;
 	}