From 723042560f7ba7853b5cff772009f5b798f88c51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Karl=20Sch=C3=A4rlund?= <kalle@maxflow.org>
Date: Thu, 27 Sep 2018 19:16:53 +0200
Subject: [PATCH 01/76] Support odd indentation sizes (fixes #17639)

Adds support for 3, 5 and 7 space indentation. Given equal support,
still prefers even numbered indentation.
---
 .../editor/common/model/indentationGuesser.ts |  4 ++--
 .../test/common/model/textModel.test.ts       | 22 +++++++++----------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/vs/editor/common/model/indentationGuesser.ts b/src/vs/editor/common/model/indentationGuesser.ts
index 01e850b65ff..c9cf713aabd 100644
--- a/src/vs/editor/common/model/indentationGuesser.ts
+++ b/src/vs/editor/common/model/indentationGuesser.ts
@@ -112,8 +112,8 @@ export function guessIndentation(source: ITextBuffer, defaultTabSize: number, de
 	let previousLineText = '';						// content of latest line that contained non-whitespace chars
 	let previousLineIndentation = 0;				// index at which latest line contained the first non-whitespace char
 
-	const ALLOWED_TAB_SIZE_GUESSES = [2, 4, 6, 8];	// limit guesses for `tabSize` to 2, 4, 6 or 8.
-	const MAX_ALLOWED_TAB_SIZE_GUESS = 8;			// max(2,4,6,8) = 8
+	const ALLOWED_TAB_SIZE_GUESSES = [2, 4, 6, 8, 3, 5, 7];	// prefer even guesses for `tabSize`, limit to [2, 8].
+	const MAX_ALLOWED_TAB_SIZE_GUESS = 8;			// max(ALLOWED_TAB_SIZE_GUESSES) = 8
 
 	let spacesDiffCount = [0, 0, 0, 0, 0, 0, 0, 0, 0];		// `tabSize` scores
 	let tmp = new SpacesDiffResult();
diff --git a/src/vs/editor/test/common/model/textModel.test.ts b/src/vs/editor/test/common/model/textModel.test.ts
index ae557f66ab4..689d106837a 100644
--- a/src/vs/editor/test/common/model/textModel.test.ts
+++ b/src/vs/editor/test/common/model/textModel.test.ts
@@ -315,7 +315,7 @@ suite('Editor Model - TextModel', () => {
 			'            ',
 			'              ',
 		], 'whitespace lines don\'t count');
-		assertGuess(true, 4, [
+		assertGuess(true, 3, [
 			'x',
 			'   x',
 			'   x',
@@ -328,8 +328,8 @@ suite('Editor Model - TextModel', () => {
 			'   x',
 			'   x',
 			'    x',
-		], 'odd number is not allowed: 6x3, 3x4');
-		assertGuess(true, 4, [
+		], '6x3, 3x4');
+		assertGuess(true, 5, [
 			'x',
 			'     x',
 			'     x',
@@ -342,8 +342,12 @@ suite('Editor Model - TextModel', () => {
 			'     x',
 			'     x',
 			'    x',
-		], 'odd number is not allowed: 6x5, 3x4');
-		assertGuess(true, 4, [
+		], '6x5, 3x4');
+		assertGuess(true, 7, [
+			'x',
+			'       x',
+			'       x',
+			'     x',
 			'x',
 			'       x',
 			'       x',
@@ -352,11 +356,7 @@ suite('Editor Model - TextModel', () => {
 			'       x',
 			'       x',
 			'    x',
-			'x',
-			'       x',
-			'       x',
-			'    x',
-		], 'odd number is not allowed: 6x7, 3x4');
+		], '6x7, 1x5, 2x4');
 		assertGuess(true, 2, [
 			'x',
 			'  x',
@@ -508,7 +508,7 @@ suite('Editor Model - TextModel', () => {
 			'        x',
 			'        x',
 		], '6x4, 2x5, 4x8');
-		assertGuess(true, undefined, [
+		assertGuess(true, 3, [
 			'x',
 			' x',
 			' x',

From 4e50ae607d4fa59e387a97283c1a2dfb21756149 Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Mon, 24 Sep 2018 11:23:23 -0700
Subject: [PATCH 02/76] Prev/Next Panel item

---
 .../workbench/browser/parts/compositeBar.ts   |  8 +++
 .../browser/parts/panel/panelActions.ts       | 65 +++++++++++++++++++
 .../browser/parts/panel/panelPart.ts          |  7 ++
 .../services/panel/common/panelService.ts     |  7 +-
 .../progress/test/progressService.test.ts     |  4 ++
 5 files changed, 90 insertions(+), 1 deletion(-)

diff --git a/src/vs/workbench/browser/parts/compositeBar.ts b/src/vs/workbench/browser/parts/compositeBar.ts
index f2984c48423..098737bae7e 100644
--- a/src/vs/workbench/browser/parts/compositeBar.ts
+++ b/src/vs/workbench/browser/parts/compositeBar.ts
@@ -72,6 +72,10 @@ export class CompositeBar extends Widget implements ICompositeBar {
 		return this.model.items;
 	}
 
+	getPinnedComposites(): ICompositeBarItem[] {
+		return this.model.pinnedItems;
+	}
+
 	create(parent: HTMLElement): HTMLElement {
 		const actionBarDiv = parent.appendChild($('.composite-bar'));
 		this.compositeSwitcherBar = this._register(new ActionBar(actionBarDiv, {
@@ -460,6 +464,10 @@ class CompositeBarModel {
 		return this.items.filter(item => item.visible);
 	}
 
+	get pinnedItems(): ICompositeBarItem[] {
+		return this.items.filter(item => item.visible && item.pinned);
+	}
+
 	private createCompositeBarItem(id: string, name: string, order: number, pinned: boolean, visible: boolean): ICompositeBarItem {
 		const options = this.options;
 		return {
diff --git a/src/vs/workbench/browser/parts/panel/panelActions.ts b/src/vs/workbench/browser/parts/panel/panelActions.ts
index 879f869d160..28cca983c57 100644
--- a/src/vs/workbench/browser/parts/panel/panelActions.ts
+++ b/src/vs/workbench/browser/parts/panel/panelActions.ts
@@ -169,6 +169,69 @@ export class PanelActivityAction extends ActivityAction {
 	}
 }
 
+export class SwitchPanelItemAction extends Action {
+
+	constructor(
+		id: string,
+		name: string,
+		@IPanelService private panelService: IPanelService
+	) {
+		super(id, name);
+	}
+
+	run(offset: number): TPromise<any> {
+		const pinnedPanels = this.panelService.getPinnedPanels();
+		const activePanel = this.panelService.getActivePanel();
+		if (!activePanel) {
+			return TPromise.as(null);
+		}
+		let targetPanelId: string;
+		for (let i = 0; i < pinnedPanels.length; i++) {
+			if (pinnedPanels[i].id === activePanel.getId()) {
+				targetPanelId = pinnedPanels[(i + pinnedPanels.length + offset) % pinnedPanels.length].id;
+				break;
+			}
+		}
+		return this.panelService.openPanel(targetPanelId, true);
+	}
+}
+
+export class PreviousPanelViewAction extends SwitchPanelItemAction {
+
+	static readonly ID = 'workbench.action.previousPanelView';
+	static LABEL = nls.localize('previousPanelView', 'Previous Panel View');
+
+	constructor(
+		id: string,
+		name: string,
+		@IPanelService panelService: IPanelService
+	) {
+		super(id, name, panelService);
+	}
+
+	run(): TPromise<any> {
+		return super.run(-1);
+	}
+}
+
+export class NextPanelViewAction extends SwitchPanelItemAction {
+
+	static readonly ID = 'workbench.action.nextPanelView';
+	static LABEL = nls.localize('nextPanelView', 'Next Panel View');
+
+	constructor(
+		id: string,
+		name: string,
+		@IPanelService panelService: IPanelService
+	) {
+		super(id, name, panelService);
+	}
+
+	public run(): TPromise<any> {
+		return super.run(1);
+	}
+}
+
 const actionRegistry = Registry.as<IWorkbenchActionRegistry>(WorkbenchExtensions.WorkbenchActions);
 actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(TogglePanelAction, TogglePanelAction.ID, TogglePanelAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.KEY_J }), 'View: Toggle Panel', nls.localize('view', "View"));
 actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(FocusPanelAction, FocusPanelAction.ID, FocusPanelAction.LABEL), 'View: Focus into Panel', nls.localize('view', "View"));
@@ -176,6 +239,8 @@ actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(ToggleMaximizedP
 actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(ClosePanelAction, ClosePanelAction.ID, ClosePanelAction.LABEL), 'View: Close Panel', nls.localize('view', "View"));
 actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(TogglePanelPositionAction, TogglePanelPositionAction.ID, TogglePanelPositionAction.LABEL), 'View: Toggle Panel Position', nls.localize('view', "View"));
 actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(ToggleMaximizedPanelAction, ToggleMaximizedPanelAction.ID, undefined), 'View: Toggle Panel Position', nls.localize('view', "View"));
+actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(PreviousPanelViewAction, PreviousPanelViewAction.ID, PreviousPanelViewAction.LABEL), 'View: Open Previous Panel View', nls.localize('view', "View"));
+actionRegistry.registerWorkbenchAction(new SyncActionDescriptor(NextPanelViewAction, NextPanelViewAction.ID, NextPanelViewAction.LABEL), 'View: Open Next Panel View', nls.localize('view', "View"));
 
 MenuRegistry.appendMenuItem(MenuId.MenubarAppearanceMenu, {
 	group: '2_workbench_layout',
diff --git a/src/vs/workbench/browser/parts/panel/panelPart.ts b/src/vs/workbench/browser/parts/panel/panelPart.ts
index d79b236141e..6b2332052da 100644
--- a/src/vs/workbench/browser/parts/panel/panelPart.ts
+++ b/src/vs/workbench/browser/parts/panel/panelPart.ts
@@ -198,6 +198,13 @@ export class PanelPart extends CompositePart<Panel> implements IPanelService {
 			.sort((v1, v2) => v1.order - v2.order);
 	}
 
+	getPinnedPanels(): PanelDescriptor[] {
+		const pinnedCompositeIds = this.compositeBar.getPinnedComposites().map(c => c.id);
+		return this.getPanels()
+			.filter(p => pinnedCompositeIds.indexOf(p.id) !== -1)
+			.sort((p1, p2) => pinnedCompositeIds.indexOf(p1.id) - pinnedCompositeIds.indexOf(p2.id));
+	}
+
 	setPanelEnablement(id: string, enabled: boolean): void {
 		const descriptor = Registry.as<PanelRegistry>(PanelExtensions.Panels).getPanels().filter(p => p.id === id).pop();
 		if (descriptor && descriptor.enabled !== enabled) {
diff --git a/src/vs/workbench/services/panel/common/panelService.ts b/src/vs/workbench/services/panel/common/panelService.ts
index 97179ea7bb8..6d73423c591 100644
--- a/src/vs/workbench/services/panel/common/panelService.ts
+++ b/src/vs/workbench/services/panel/common/panelService.ts
@@ -34,10 +34,15 @@ export interface IPanelService {
 	getActivePanel(): IPanel;
 
 	/**
-	 * Returns all enabled panels
+	 * * Returns all built-in panels following the default order (Problems - Output - Debug Console - Terminal)
 	 */
 	getPanels(): IPanelIdentifier[];
 
+	/**
+	 * Returns pinned panels following the visual order
+	 */
+	getPinnedPanels(): IPanelIdentifier[];
+
 	/**
 	 * Enables or disables a panel. Disabled panels are completly hidden from UI.
 	 * By default all panels are enabled.
diff --git a/src/vs/workbench/services/progress/test/progressService.test.ts b/src/vs/workbench/services/progress/test/progressService.test.ts
index e81c13a61db..00c3b62b128 100644
--- a/src/vs/workbench/services/progress/test/progressService.test.ts
+++ b/src/vs/workbench/services/progress/test/progressService.test.ts
@@ -79,6 +79,10 @@ class TestPanelService implements IPanelService {
 		return [];
 	}
 
+	public getPinnedPanels(): any[] {
+		return [];
+	}
+
 	public getActivePanel(): IViewlet {
 		return activeViewlet;
 	}

From 8869632ba20473f1e795c1217aab4caf7875ce21 Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Mon, 24 Sep 2018 14:34:36 -0700
Subject: [PATCH 03/76] Prev/Next Sidebar View

---
 .../parts/activitybar/activitybarActions.ts   | 108 +++++++++++++++---
 .../parts/activitybar/activitybarPart.ts      |   8 +-
 .../browser/parts/panel/panelActions.ts       |   6 +-
 .../workbench/electron-browser/workbench.ts   |   2 +-
 .../activity/browser/activityService.ts       |   5 +
 .../services/activity/common/activity.ts      |   5 +
 .../services/viewlet/browser/viewlet.ts       |   2 +-
 7 files changed, 113 insertions(+), 23 deletions(-)

diff --git a/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts b/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
index 1ab2e743b9e..592230a3491 100644
--- a/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
+++ b/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
@@ -5,26 +5,31 @@
 
 'use strict';
 
-import 'vs/css!./media/activityaction';
 import * as DOM from 'vs/base/browser/dom';
-import { EventType as TouchEventType, GestureEvent } from 'vs/base/browser/touch';
-import { TPromise } from 'vs/base/common/winjs.base';
-import { Action } from 'vs/base/common/actions';
-import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
-import { ViewletDescriptor } from 'vs/workbench/browser/viewlet';
-import { IActivity, IGlobalActivity } from 'vs/workbench/common/activity';
-import { dispose } from 'vs/base/common/lifecycle';
-import { IViewletService, } from 'vs/workbench/services/viewlet/browser/viewlet';
-import { IPartService, Parts } from 'vs/workbench/services/part/common/partService';
-import { IThemeService, ITheme, registerThemingParticipant, ICssStyleCollector } from 'vs/platform/theme/common/themeService';
-import { activeContrastBorder, focusBorder } from 'vs/platform/theme/common/colorRegistry';
-import { StandardMouseEvent } from 'vs/base/browser/mouseEvent';
-import { KeyCode } from 'vs/base/common/keyCodes';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
-import { ActivityAction, ActivityActionItem, ICompositeBarColors, ToggleCompositePinnedAction, ICompositeBar } from 'vs/workbench/browser/parts/compositeBarActions';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { StandardMouseEvent } from 'vs/base/browser/mouseEvent';
+import { EventType as TouchEventType, GestureEvent } from 'vs/base/browser/touch';
+import { Action } from 'vs/base/common/actions';
+import { KeyCode } from 'vs/base/common/keyCodes';
+import { dispose } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
+import { TPromise } from 'vs/base/common/winjs.base';
+import 'vs/css!./media/activityaction';
+import * as nls from 'vs/nls';
+import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
+import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { activeContrastBorder, focusBorder } from 'vs/platform/theme/common/colorRegistry';
+import { ICssStyleCollector, ITheme, IThemeService, registerThemingParticipant } from 'vs/platform/theme/common/themeService';
+import { ActivityAction, ActivityActionItem, ICompositeBar, ICompositeBarColors, ToggleCompositePinnedAction } from 'vs/workbench/browser/parts/compositeBarActions';
+import { ViewletDescriptor } from 'vs/workbench/browser/viewlet';
+import { Extensions as ActionExtensions, IWorkbenchActionRegistry } from 'vs/workbench/common/actions';
+import { IActivity, IGlobalActivity } from 'vs/workbench/common/activity';
 import { ACTIVITY_BAR_FOREGROUND } from 'vs/workbench/common/theme';
+import { IActivityService } from 'vs/workbench/services/activity/common/activity';
+import { IPartService, Parts } from 'vs/workbench/services/part/common/partService';
+import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
 
 export class ViewletActivityAction extends ActivityAction {
 
@@ -191,6 +196,77 @@ export class PlaceHolderToggleCompositePinnedAction extends ToggleCompositePinne
 	}
 }
 
+class SwitchSidebarViewAction extends Action {
+
+	constructor(
+		id: string,
+		name: string,
+		@IViewletService private viewletService: IViewletService,
+		@IActivityService private activityService: IActivityService
+	) {
+		super(id, name);
+	}
+
+	run(offset: number): TPromise<any> {
+		const pinnedViewletIds = this.activityService.getPinnedViewletIds();
+
+		const activeViewlet = this.viewletService.getActiveViewlet();
+		if (!activeViewlet) {
+			return TPromise.as(null);
+		}
+		let targetViewletId: string;
+		for (let i = 0; i < pinnedViewletIds.length; i++) {
+			if (pinnedViewletIds[i] === activeViewlet.getId()) {
+				targetViewletId = pinnedViewletIds[(i + pinnedViewletIds.length + offset) % pinnedViewletIds.length];
+				break;
+			}
+		}
+		return this.viewletService.openViewlet(targetViewletId, true);
+	}
+}
+
+export class PreviousSidebarViewAction extends SwitchSidebarViewAction {
+
+	static readonly ID = 'workbench.action.previousSidebarView';
+	static LABEL = nls.localize('previousSidebarView', 'Previous Sidebar View');
+
+	constructor(
+		id: string,
+		name: string,
+		@IViewletService viewletService: IViewletService,
+		@IActivityService activityService: IActivityService
+	) {
+		super(id, name, viewletService, activityService);
+	}
+
+	run(): TPromise<any> {
+		return super.run(-1);
+	}
+}
+
+export class NextSidebarViewAction extends SwitchSidebarViewAction {
+
+	static readonly ID = 'workbench.action.nextSidebarView';
+	static LABEL = nls.localize('nextSidebarView', 'Next Sidebar View');
+
+	constructor(
+		id: string,
+		name: string,
+		@IViewletService viewletService: IViewletService,
+		@IActivityService activityService: IActivityService
+	) {
+		super(id, name, viewletService, activityService);
+	}
+
+	run(): TPromise<any> {
+		return super.run(1);
+	}
+}
+
+const registry = Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions);
+registry.registerWorkbenchAction(new SyncActionDescriptor(PreviousSidebarViewAction, PreviousSidebarViewAction.ID, PreviousSidebarViewAction.LABEL), 'View: Open Previous Sidebar View', nls.localize('view', "View"));
+registry.registerWorkbenchAction(new SyncActionDescriptor(NextSidebarViewAction, NextSidebarViewAction.ID, NextSidebarViewAction.LABEL), 'View: Open Next Sidebar View', nls.localize('view', "View"));
+
 registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 
 	const activeForegroundColor = theme.getColor(ACTIVITY_BAR_FOREGROUND);
diff --git a/src/vs/workbench/browser/parts/activitybar/activitybarPart.ts b/src/vs/workbench/browser/parts/activitybar/activitybarPart.ts
index 4ef749c3fda..74b9dc71297 100644
--- a/src/vs/workbench/browser/parts/activitybar/activitybarPart.ts
+++ b/src/vs/workbench/browser/parts/activitybar/activitybarPart.ts
@@ -306,8 +306,12 @@ export class ActivitybarPart extends Part {
 		}
 	}
 
-	getPinned(): string[] {
-		return this.viewletService.getViewlets().map(v => v.id).filter(id => this.compositeBar.isPinned(id));
+	getPinnedViewletIds(): string[] {
+		const pinnedCompositeIds = this.compositeBar.getPinnedComposites().map(v => v.id);
+		return this.viewletService.getViewlets()
+			.filter(v => this.compositeBar.isPinned(v.id))
+			.sort((v1, v2) => pinnedCompositeIds.indexOf(v1.id) - pinnedCompositeIds.indexOf(v2.id))
+			.map(v => v.id);
 	}
 
 	layout(dimension: Dimension): Dimension[] {
diff --git a/src/vs/workbench/browser/parts/panel/panelActions.ts b/src/vs/workbench/browser/parts/panel/panelActions.ts
index 28cca983c57..34582928dec 100644
--- a/src/vs/workbench/browser/parts/panel/panelActions.ts
+++ b/src/vs/workbench/browser/parts/panel/panelActions.ts
@@ -169,7 +169,7 @@ export class PanelActivityAction extends ActivityAction {
 	}
 }
 
-export class SwitchPanelItemAction extends Action {
+export class SwitchPanelViewAction extends Action {
 
 	constructor(
 		id: string,
@@ -196,7 +196,7 @@ export class SwitchPanelItemAction extends Action {
 	}
 }
 
-export class PreviousPanelViewAction extends SwitchPanelItemAction {
+export class PreviousPanelViewAction extends SwitchPanelViewAction {
 
 	static readonly ID = 'workbench.action.previousPanelView';
 	static LABEL = nls.localize('previousPanelView', 'Previous Panel View');
@@ -214,7 +214,7 @@ export class PreviousPanelViewAction extends SwitchPanelItemAction {
 	}
 }
 
-export class NextPanelViewAction extends SwitchPanelItemAction {
+export class NextPanelViewAction extends SwitchPanelViewAction {
 
 	static readonly ID = 'workbench.action.nextPanelView';
 	static LABEL = nls.localize('nextPanelView', 'Next Panel View');
diff --git a/src/vs/workbench/electron-browser/workbench.ts b/src/vs/workbench/electron-browser/workbench.ts
index 2952ac488fe..9b322ad8934 100644
--- a/src/vs/workbench/electron-browser/workbench.ts
+++ b/src/vs/workbench/electron-browser/workbench.ts
@@ -762,7 +762,7 @@ export class Workbench extends Disposable implements IPartService {
 
 			return {
 				customKeybindingsCount: this.keybindingService.customKeybindingsCount(),
-				pinnedViewlets: this.activitybarPart.getPinned(),
+				pinnedViewlets: this.activitybarPart.getPinnedViewletIds(),
 				restoredViewlet: viewletIdToRestore,
 				restoredEditorsCount: this.editorService.visibleEditors.length
 			};
diff --git a/src/vs/workbench/services/activity/browser/activityService.ts b/src/vs/workbench/services/activity/browser/activityService.ts
index 27bbe40af63..f230d4a2303 100644
--- a/src/vs/workbench/services/activity/browser/activityService.ts
+++ b/src/vs/workbench/services/activity/browser/activityService.ts
@@ -28,4 +28,9 @@ export class ActivityService implements IActivityService {
 
 		return this.activitybarPart.showActivity(compositeOrActionId, badge, clazz, priority);
 	}
+
+	getPinnedViewletIds(): string[] {
+		return this.activitybarPart.getPinnedViewletIds();
+	}
+
 }
diff --git a/src/vs/workbench/services/activity/common/activity.ts b/src/vs/workbench/services/activity/common/activity.ts
index 27513b65417..06d2d83edd7 100644
--- a/src/vs/workbench/services/activity/common/activity.ts
+++ b/src/vs/workbench/services/activity/common/activity.ts
@@ -67,4 +67,9 @@ export interface IActivityService {
 	 * Show activity in the panel for the given panel or in the activitybar for the given viewlet or global action.
 	 */
 	showActivity(compositeOrActionId: string, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+
+	/**
+	 * Returns id of pinned viewlets following the visual order
+	 */
+	getPinnedViewletIds(): string[];
 }
diff --git a/src/vs/workbench/services/viewlet/browser/viewlet.ts b/src/vs/workbench/services/viewlet/browser/viewlet.ts
index a6903bb9fb9..1f0b49bb12f 100644
--- a/src/vs/workbench/services/viewlet/browser/viewlet.ts
+++ b/src/vs/workbench/services/viewlet/browser/viewlet.ts
@@ -42,7 +42,7 @@ export interface IViewletService {
 	getViewlet(id: string): ViewletDescriptor;
 
 	/**
-	 * Returns all viewlets
+	 * Returns all enabled viewlets following the default order (Explorer - Search - SCM - Debug - Extensions)
 	 */
 	getAllViewlets(): ViewletDescriptor[];
 

From 660209ca74f63033ea013d42dfc34954e8cee1c8 Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Mon, 24 Sep 2018 14:36:39 -0700
Subject: [PATCH 04/76] Import order

---
 .../workbench/browser/parts/activitybar/activitybarActions.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts b/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
index 592230a3491..ec9b4b364e7 100644
--- a/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
+++ b/src/vs/workbench/browser/parts/activitybar/activitybarActions.ts
@@ -5,6 +5,8 @@
 
 'use strict';
 
+import 'vs/css!./media/activityaction';
+import * as nls from 'vs/nls';
 import * as DOM from 'vs/base/browser/dom';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { StandardMouseEvent } from 'vs/base/browser/mouseEvent';
@@ -14,8 +16,6 @@ import { KeyCode } from 'vs/base/common/keyCodes';
 import { dispose } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
-import 'vs/css!./media/activityaction';
-import * as nls from 'vs/nls';
 import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { Registry } from 'vs/platform/registry/common/platform';

From 7d30396d0cff7184b8e585a9d49893b41a6f5d8b Mon Sep 17 00:00:00 2001
From: benjamenhogben <bhogben@gmail.com>
Date: Fri, 5 Oct 2018 09:48:33 +0100
Subject: [PATCH 05/76] Add throwable to try/catch block

---
 extensions/php/snippets/php.snippets.json | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/extensions/php/snippets/php.snippets.json b/extensions/php/snippets/php.snippets.json
index c8dc8405300..1010dad8993 100644
--- a/extensions/php/snippets/php.snippets.json
+++ b/extensions/php/snippets/php.snippets.json
@@ -254,6 +254,8 @@
 		"body": [
 			"try {",
 			"\t${1://code...}",
+			"} catch (\\Throwable \\$$t) {",
+			"\t${2://throw $$t;}",
 			"} catch (\\Exception \\$$e) {",
 			"\t${2://throw $$e;}",
 			"}"

From f0b51ea9ad914cadd0879d9ca784a05df528a7e8 Mon Sep 17 00:00:00 2001
From: benjamenhogben <bhogben@gmail.com>
Date: Fri, 5 Oct 2018 10:50:02 +0100
Subject: [PATCH 06/76] Catch Throwable user editable

---
 extensions/php/snippets/php.snippets.json | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/extensions/php/snippets/php.snippets.json b/extensions/php/snippets/php.snippets.json
index 1010dad8993..f964dc42a01 100644
--- a/extensions/php/snippets/php.snippets.json
+++ b/extensions/php/snippets/php.snippets.json
@@ -254,10 +254,8 @@
 		"body": [
 			"try {",
 			"\t${1://code...}",
-			"} catch (\\Throwable \\$$t) {",
-			"\t${2://throw $$t;}",
-			"} catch (\\Exception \\$$e) {",
-			"\t${2://throw $$e;}",
+			"} catch (${2:\\Throwable} ${3:$$t}) {",
+			"\t${4://throw $$th;}",
 			"}"
 		],
 		"description": "Try catch block"

From 75dc89debcc71398b23761e3af4d5846ad584a1e Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Mon, 8 Oct 2018 11:13:17 +0200
Subject: [PATCH 07/76] more measurement prop...

---
 src/vs/editor/contrib/suggest/suggestController.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/editor/contrib/suggest/suggestController.ts b/src/vs/editor/contrib/suggest/suggestController.ts
index 0f873ea9bc3..74a5df0502c 100644
--- a/src/vs/editor/contrib/suggest/suggestController.ts
+++ b/src/vs/editor/contrib/suggest/suggestController.ts
@@ -284,7 +284,7 @@ export class SuggestController implements IEditorContribution {
 		/* __GDPR__
 			"acceptSuggestion" : {
 				"type" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
-				"multiline" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+				"multiline" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
 			}
 		*/
 		service.publicLog('acceptSuggestion', {

From a39a101d424075d20ba02ee6ed6ce7f2b9c2f7e4 Mon Sep 17 00:00:00 2001
From: Christof Marti <chrmarti@microsoft.com>
Date: Mon, 8 Oct 2018 11:14:13 +0200
Subject: [PATCH 08/76] Don't assign 'editor' label

---
 .github/classifier.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/classifier.yml b/.github/classifier.yml
index a7bcb40c96f..eba4910f445 100644
--- a/.github/classifier.yml
+++ b/.github/classifier.yml
@@ -20,7 +20,10 @@
         },
         diff-editor: [],
         dropdown: [],
-        editor: [],
+        editor: {
+            assignees: [],
+            assignLabel: false
+        },
         editor-1000-limit: [],
         editor-autoclosing: [],
         editor-autoindent: [],

From 96eb2ffc55273753c4e6c38e3c1f9a5b5c01e649 Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Mon, 8 Oct 2018 11:23:16 +0200
Subject: [PATCH 09/76] debug: minimal updates to repl title when repl is not
 visible

---
 .../parts/debug/electron-browser/repl.ts        | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/vs/workbench/parts/debug/electron-browser/repl.ts b/src/vs/workbench/parts/debug/electron-browser/repl.ts
index 31b3b76547b..4f9dbc8019f 100644
--- a/src/vs/workbench/parts/debug/electron-browser/repl.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/repl.ts
@@ -127,11 +127,23 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 				}
 			}
 			this.replInput.updateOptions({ readOnly: !session });
-			this.updateInputDecoration();
+			if (this.isVisible()) {
+				this.updateInputDecoration();
+			}
 		}));
 		this._register(this.panelService.onDidPanelOpen(panel => this.refreshReplElements(true)));
 		this._register(this.debugService.onDidNewSession(() => this.updateTitleArea()));
-		this._register(this.themeService.onThemeChange(() => this.updateInputDecoration()));
+		this._register(this.debugService.onDidEndSession(() => {
+			if (this.debugService.getModel().getSessions().length === 0 && this.isVisible()) {
+				// Only hide the session drop down when there are 0 sessions
+				this.updateTitleArea();
+			}
+		}));
+		this._register(this.themeService.onThemeChange(() => {
+			if (this.isVisible()) {
+				this.updateInputDecoration();
+			}
+		}));
 	}
 
 	private refreshReplElements(noDelay: boolean): void {
@@ -356,7 +368,6 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return this.instantiationService.createInstance(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL);
 	}
 
-	@memoize
 	private get focusSessionActionItem(): FocusSessionActionItem {
 		return this.instantiationService.createInstance(FocusSessionActionItem, this.focusSessionAction);
 	}

From e2027598992e56d7f6f6f26f804d53449ea1a2ee Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Mon, 8 Oct 2018 11:26:07 +0200
Subject: [PATCH 10/76] repl: minor fix

---
 src/vs/workbench/parts/debug/electron-browser/repl.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/workbench/parts/debug/electron-browser/repl.ts b/src/vs/workbench/parts/debug/electron-browser/repl.ts
index 4f9dbc8019f..0a0d7127d64 100644
--- a/src/vs/workbench/parts/debug/electron-browser/repl.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/repl.ts
@@ -134,7 +134,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		this._register(this.panelService.onDidPanelOpen(panel => this.refreshReplElements(true)));
 		this._register(this.debugService.onDidNewSession(() => this.updateTitleArea()));
 		this._register(this.debugService.onDidEndSession(() => {
-			if (this.debugService.getModel().getSessions().length === 0 && this.isVisible()) {
+			if (this.debugService.getModel().getSessions().length === 0) {
 				// Only hide the session drop down when there are 0 sessions
 				this.updateTitleArea();
 			}

From 1580cd184645494128e1013d750800392ee58b7d Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Mon, 8 Oct 2018 12:38:26 +0200
Subject: [PATCH 11/76] first version of simple clipboard API, #217

---
 src/vs/vscode.proposed.d.ts                   | 13 +++++++++
 .../extensionHost.contribution.ts             |  1 +
 .../electron-browser/mainThreadClipboard.ts   | 27 +++++++++++++++++++
 src/vs/workbench/api/node/extHost.api.impl.ts |  6 +++++
 src/vs/workbench/api/node/extHost.protocol.ts |  6 +++++
 src/vs/workbench/api/node/extHostClipboard.ts | 26 ++++++++++++++++++
 6 files changed, 79 insertions(+)
 create mode 100644 src/vs/workbench/api/electron-browser/mainThreadClipboard.ts
 create mode 100644 src/vs/workbench/api/node/extHostClipboard.ts

diff --git a/src/vs/vscode.proposed.d.ts b/src/vs/vscode.proposed.d.ts
index 29317dff255..c16a02dd272 100644
--- a/src/vs/vscode.proposed.d.ts
+++ b/src/vs/vscode.proposed.d.ts
@@ -11,6 +11,19 @@ declare module 'vscode' {
 		export function sampleFunction(): Thenable<any>;
 	}
 
+	//#region Joh - clipboard https://github.com/Microsoft/vscode/issues/217
+
+	export interface Clipboard {
+		readText(): Promise<string>;
+		writeText(value: string): Promise<void>;
+	}
+
+	export namespace env {
+		export const clipboard: Clipboard;
+	}
+
+	//#endregion
+
 	//#region Joh - read/write in chunks
 
 	export interface FileSystemProvider {
diff --git a/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts b/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts
index 681c0ac477d..1b16047d2a9 100644
--- a/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts
+++ b/src/vs/workbench/api/electron-browser/extensionHost.contribution.ts
@@ -15,6 +15,7 @@ import { LanguageConfigurationFileHandler } from 'vs/workbench/parts/codeEditor/
 
 // --- mainThread participants
 import 'vs/workbench/api/node/apiCommands';
+import './mainThreadClipboard';
 import './mainThreadCommands';
 import './mainThreadConfiguration';
 import './mainThreadDebugService';
diff --git a/src/vs/workbench/api/electron-browser/mainThreadClipboard.ts b/src/vs/workbench/api/electron-browser/mainThreadClipboard.ts
new file mode 100644
index 00000000000..14c3f9bb644
--- /dev/null
+++ b/src/vs/workbench/api/electron-browser/mainThreadClipboard.ts
@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { clipboard } from 'electron';
+import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
+import { MainContext, MainThreadClipboardShape } from '../node/extHost.protocol';
+
+@extHostNamedCustomer(MainContext.MainThreadClipboard)
+export class MainThreadCommands implements MainThreadClipboardShape {
+
+	dispose(): void {
+		// nothing
+	}
+
+	$readText(): Promise<string> {
+		return Promise.resolve(clipboard.readText());
+	}
+
+	$writeText(value: string): Promise<void> {
+		clipboard.writeText(value);
+		return undefined;
+	}
+}
diff --git a/src/vs/workbench/api/node/extHost.api.impl.ts b/src/vs/workbench/api/node/extHost.api.impl.ts
index 37f9eb1ba19..a4ba38dd2ae 100644
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -61,6 +61,7 @@ import { ExtHostComments } from './extHostComments';
 import { ExtHostSearch } from './extHostSearch';
 import { ExtHostUrls } from './extHostUrls';
 import { localize } from 'vs/nls';
+import { ExtHostClipboard } from 'vs/workbench/api/node/extHostClipboard';
 
 export interface IExtensionApiFactory {
 	(extension: IExtensionDescription): typeof vscode;
@@ -134,6 +135,7 @@ export function createApiFactory(
 	rpcProtocol.assertRegistered(expected);
 
 	// Other instances
+	const extHostClipboard = new ExtHostClipboard(rpcProtocol);
 	const extHostMessageService = new ExtHostMessageService(rpcProtocol);
 	const extHostDialogs = new ExtHostDialogs(rpcProtocol);
 	const extHostStatusBar = new ExtHostStatusBar(rpcProtocol);
@@ -237,6 +239,10 @@ export function createApiFactory(
 			get onDidChangeLogLevel() {
 				checkProposedApiEnabled(extension);
 				return extHostLogService.onDidChangeLogLevel;
+			},
+			get clipboard(): vscode.Clipboard {
+				checkProposedApiEnabled(extension);
+				return extHostClipboard;
 			}
 		});
 
diff --git a/src/vs/workbench/api/node/extHost.protocol.ts b/src/vs/workbench/api/node/extHost.protocol.ts
index 113ab79fe56..8debd6373de 100644
--- a/src/vs/workbench/api/node/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -86,6 +86,11 @@ export interface IMainContext extends IRPCProtocol {
 
 // --- main thread
 
+export interface MainThreadClipboardShape extends IDisposable {
+	$readText(): Promise<string>;
+	$writeText(value: string): Promise<void>;
+}
+
 export interface MainThreadCommandsShape extends IDisposable {
 	$registerCommand(id: string): void;
 	$unregisterCommand(id: string): void;
@@ -1014,6 +1019,7 @@ export interface ExtHostCommentsShape {
 // --- proxy identifiers
 
 export const MainContext = {
+	MainThreadClipboard: <ProxyIdentifier<MainThreadClipboardShape>>createMainId<MainThreadClipboardShape>('MainThreadClipboard'),
 	MainThreadCommands: <ProxyIdentifier<MainThreadCommandsShape>>createMainId<MainThreadCommandsShape>('MainThreadCommands'),
 	MainThreadComments: createMainId<MainThreadCommentsShape>('MainThreadComments'),
 	MainThreadConfiguration: createMainId<MainThreadConfigurationShape>('MainThreadConfiguration'),
diff --git a/src/vs/workbench/api/node/extHostClipboard.ts b/src/vs/workbench/api/node/extHostClipboard.ts
new file mode 100644
index 00000000000..342845ba00d
--- /dev/null
+++ b/src/vs/workbench/api/node/extHostClipboard.ts
@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { IMainContext, MainContext, MainThreadClipboardShape } from 'vs/workbench/api/node/extHost.protocol';
+import * as vscode from 'vscode';
+
+export class ExtHostClipboard implements vscode.Clipboard {
+
+	private readonly _proxy: MainThreadClipboardShape;
+
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadClipboard);
+	}
+
+	readText(): Promise<string> {
+		return this._proxy.$readText();
+	}
+
+	writeText(value: string): Promise<void> {
+		return this._proxy.$writeText(value);
+	}
+}

From f91e70bcdb7021fd3bb354d1ea5331260ce7abbb Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Mon, 8 Oct 2018 15:10:04 +0200
Subject: [PATCH 12/76] expose label tuple in API, #56337

---
 src/vs/vscode.d.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/vs/vscode.d.ts b/src/vs/vscode.d.ts
index e53b48e2b7e..13b07a2fc06 100644
--- a/src/vs/vscode.d.ts
+++ b/src/vs/vscode.d.ts
@@ -3023,10 +3023,13 @@ declare module 'vscode' {
 	export class ParameterInformation {
 
 		/**
-		 * The label of this signature. *Note*: Must be a substring of its
-		 * containing signature information's [label](#SignatureInformation.label).
+		 * The label of this signature.
+		 *
+		 * Either a string or inclusive start and exclusive end offsets within its containing
+		 * [signature label](#SignatureInformation.label). *Note*: A label of type string must be
+		 * a substring of its containing signature information's [label](#SignatureInformation.label).
 		 */
-		label: string;
+		label: string | [number, number];
 
 		/**
 		 * The human-readable doc-comment of this signature. Will be shown

From e69c3db65a17c9cfc6606fbe7e7449861c440766 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Mon, 8 Oct 2018 15:38:11 +0200
Subject: [PATCH 13/76] fix #59966

---
 .../parts/snippets/electron-browser/configureSnippets.ts   | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/vs/workbench/parts/snippets/electron-browser/configureSnippets.ts b/src/vs/workbench/parts/snippets/electron-browser/configureSnippets.ts
index 3995d569a17..74a5456754e 100644
--- a/src/vs/workbench/parts/snippets/electron-browser/configureSnippets.ts
+++ b/src/vs/workbench/parts/snippets/electron-browser/configureSnippets.ts
@@ -19,6 +19,7 @@ import { IQuickPickItem, IQuickInputService, QuickPickInput } from 'vs/platform/
 import { SnippetSource } from 'vs/workbench/parts/snippets/electron-browser/snippetsFile';
 import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
 import { IFileService } from 'vs/platform/files/common/files';
+import { INotificationService } from 'vs/platform/notification/common/notification';
 
 const id = 'workbench.action.openSnippets';
 
@@ -117,7 +118,7 @@ async function computePicks(snippetService: ISnippetsService, envService: IEnvir
 	return { existing, future };
 }
 
-async function createGlobalSnippetFile(defaultPath: URI, windowService: IWindowService, fileService: IFileService, opener: IOpenerService) {
+async function createGlobalSnippetFile(defaultPath: URI, windowService: IWindowService, notificationService: INotificationService, fileService: IFileService, opener: IOpenerService) {
 
 	await fileService.createFolder(defaultPath);
 	await timeout(100); // ensure quick pick closes...
@@ -131,6 +132,7 @@ async function createGlobalSnippetFile(defaultPath: URI, windowService: IWindowS
 	}
 	const resource = URI.file(path);
 	if (dirname(resource.fsPath) !== defaultPath.fsPath) {
+		notificationService.error(nls.localize('badPath', "Snippets must be inside this folder: '{0}'. ", defaultPath.fsPath));
 		return undefined;
 	}
 
@@ -190,6 +192,7 @@ CommandsRegistry.registerCommand(id, async accessor => {
 	const windowService = accessor.get(IWindowService);
 	const modeService = accessor.get(IModeService);
 	const envService = accessor.get(IEnvironmentService);
+	const notificationService = accessor.get(INotificationService);
 	const workspaceService = accessor.get(IWorkspaceContextService);
 	const fileService = accessor.get(IFileService);
 
@@ -221,7 +224,7 @@ CommandsRegistry.registerCommand(id, async accessor => {
 	});
 
 	if (globalSnippetPicks.indexOf(pick as GlobalSnippetPick) >= 0) {
-		return createGlobalSnippetFile((pick as GlobalSnippetPick).uri, windowService, fileService, opener);
+		return createGlobalSnippetFile((pick as GlobalSnippetPick).uri, windowService, notificationService, fileService, opener);
 	} else if (ISnippetPick.is(pick)) {
 		if (pick.hint) {
 			await createLanguageSnippetFile(pick, fileService);

From 61ee5fad062f9ee123a96c178f192a5fa3a9d371 Mon Sep 17 00:00:00 2001
From: Benjamin Pasero <benjpas@microsoft.com>
Date: Mon, 8 Oct 2018 15:52:35 +0200
Subject: [PATCH 14/76] fix typo

---
 .../services/configuration/node/configurationService.ts       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/vs/workbench/services/configuration/node/configurationService.ts b/src/vs/workbench/services/configuration/node/configurationService.ts
index 302ba8a2a22..ea48e1b4e4a 100644
--- a/src/vs/workbench/services/configuration/node/configurationService.ts
+++ b/src/vs/workbench/services/configuration/node/configurationService.ts
@@ -322,7 +322,7 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 
 	private createWorkspace(arg: IWorkspaceIdentifier | URI | IWindowConfiguration): Promise<Workspace> {
 		if (isWorkspaceIdentifier(arg)) {
-			return this.createMulitFolderWorkspace(arg);
+			return this.createMultiFolderWorkspace(arg);
 		}
 
 		if (isSingleFolderWorkspaceIdentifier(arg)) {
@@ -332,7 +332,7 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 		return this.createEmptyWorkspace(arg);
 	}
 
-	private createMulitFolderWorkspace(workspaceIdentifier: IWorkspaceIdentifier): Promise<Workspace> {
+	private createMultiFolderWorkspace(workspaceIdentifier: IWorkspaceIdentifier): Promise<Workspace> {
 		const workspaceConfigPath = URI.file(workspaceIdentifier.configPath);
 		return this.workspaceConfiguration.load(workspaceConfigPath)
 			.then(() => {

From fc971b16741c1c035fd3eb2bfc99526cf6dd016b Mon Sep 17 00:00:00 2001
From: Benjamin Pasero <benjamin.pasero@gmail.com>
Date: Mon, 8 Oct 2018 16:08:23 +0200
Subject: [PATCH 15/76] electron@2.0.11 (#60143)

---
 .yarnrc                 | 2 +-
 OSSREADME.json          | 2 +-
 test/smoke/package.json | 2 +-
 test/smoke/yarn.lock    | 8 ++++----
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.yarnrc b/.yarnrc
index 40cb5766ccb..55749a8a0a7 100644
--- a/.yarnrc
+++ b/.yarnrc
@@ -1,3 +1,3 @@
 disturl "https://atom.io/download/electron"
-target "2.0.9"
+target "2.0.11"
 runtime "electron"
diff --git a/OSSREADME.json b/OSSREADME.json
index 98c9d0476b5..c59395867eb 100644
--- a/OSSREADME.json
+++ b/OSSREADME.json
@@ -51,7 +51,7 @@
 },
 {
 	"name": "electron",
-	"version": "2.0.9",
+	"version": "2.0.11",
 	"license": "MIT",
 	"repositoryURL": "https://github.com/electron/electron",
 	"isProd": true
diff --git a/test/smoke/package.json b/test/smoke/package.json
index 5c895fb7209..ef0dd229f41 100644
--- a/test/smoke/package.json
+++ b/test/smoke/package.json
@@ -22,7 +22,7 @@
     "@types/webdriverio": "4.6.1",
     "concurrently": "^3.5.1",
     "cpx": "^1.5.0",
-    "electron": "^2.0.9",
+    "electron": "^2.0.11",
     "htmlparser2": "^3.9.2",
     "mkdirp": "^0.5.1",
     "mocha": "^5.2.0",
diff --git a/test/smoke/yarn.lock b/test/smoke/yarn.lock
index 3ebe0c75ec5..0f246945f20 100644
--- a/test/smoke/yarn.lock
+++ b/test/smoke/yarn.lock
@@ -584,10 +584,10 @@ electron-download@^3.0.1:
     semver "^5.3.0"
     sumchecker "^1.2.0"
 
-electron@^2.0.9:
-  version "2.0.9"
-  resolved "https://registry.yarnpkg.com/electron/-/electron-2.0.9.tgz#dfc863d653fa3a2dd4fea0c63303df9c0e33c602"
-  integrity sha512-xRefYuz6C65ahX8vDwIJxr1Y5ffFa106dugZEbl23yLKfrAG01lh5csBJ9hJwCBPLHp2zj/9PGoJ8dt5zlzOvQ==
+electron@^2.0.11:
+  version "2.0.11"
+  resolved "https://registry.yarnpkg.com/electron/-/electron-2.0.11.tgz#8e352a83ec607471e82d323a2adc7e7b53698e79"
+  integrity sha512-bFTMDQN3epfiymqTPdgffyTxuy/7A52sIkW7Hos+hY5XLPArOXLXAKx1JtB3dM7CcPfZa+5qp/J3cPCidh5WXg==
   dependencies:
     "@types/node" "^8.0.24"
     electron-download "^3.0.1"

From ff085d3bc7e4098f4965e4649f226c60ff46f229 Mon Sep 17 00:00:00 2001
From: Alex Dima <alexdima@microsoft.com>
Date: Mon, 8 Oct 2018 16:11:59 +0200
Subject: [PATCH 16/76] Fixes #59328

---
 src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts b/src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts
index 2b6a07650d2..05e59918069 100644
--- a/src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts
+++ b/src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts
@@ -138,7 +138,7 @@ export class ViewCursor {
 				width = dom.computeScreenAwareSize(1);
 			}
 			let left = visibleRange.left;
-			if (width >= 2) {
+			if (width >= 2 && left >= 1) {
 				// try to center cursor
 				left -= 1;
 			}

From a2455b79a0dfe1f928f0f015b7e53ddff770c5a8 Mon Sep 17 00:00:00 2001
From: Benjamin Pasero <benjpas@microsoft.com>
Date: Mon, 8 Oct 2018 16:54:28 +0200
Subject: [PATCH 17/76] revert "exploration"

---
 build/tfs/common/publish.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/tfs/common/publish.ts b/build/tfs/common/publish.ts
index 100d2b88581..7a74dc6106e 100644
--- a/build/tfs/common/publish.ts
+++ b/build/tfs/common/publish.ts
@@ -152,7 +152,7 @@ async function publish(commit: string, quality: string, platform: string, type:
 
 	const queuedBy = process.env['BUILD_QUEUEDBY']!;
 	const sourceBranch = process.env['BUILD_SOURCEBRANCH']!;
-	const isReleased = (quality === 'insider' || quality === 'exploration')
+	const isReleased = quality === 'insider'
 		&& /^master$|^refs\/heads\/master$/.test(sourceBranch)
 		&& /Project Collection Service Accounts|Microsoft.VisualStudio.Services.TFS/.test(queuedBy);
 

From 6d8b6d39ccf849ecd2805937d386a8c159559e1f Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 08:10:15 -0700
Subject: [PATCH 18/76] Remove css vendor pefixes for transition and transform
 (#60050)

The css3 `transform` and `transition` properties are now widely supported. I do not believe we need to ship vendor prefixed rules for these anymore
---
 src/vs/base/browser/ui/actionbar/actionbar.css     | 14 +-------------
 src/vs/base/browser/ui/menu/menu.css               |  8 --------
 src/vs/base/browser/ui/progressbar/progressbar.css |  4 ----
 .../base/browser/ui/scrollbar/media/scrollbars.css |  8 --------
 src/vs/base/browser/ui/splitview/panelview.css     |  8 --------
 src/vs/editor/contrib/find/findWidget.css          |  6 ------
 src/vs/editor/contrib/find/simpleFindWidget.css    |  5 -----
 .../contrib/parameterHints/parameterHints.css      |  3 ---
 .../parts/debug/browser/media/debugViewlet.css     |  2 --
 9 files changed, 1 insertion(+), 57 deletions(-)

diff --git a/src/vs/base/browser/ui/actionbar/actionbar.css b/src/vs/base/browser/ui/actionbar/actionbar.css
index 4ff042d038f..25795ddb631 100644
--- a/src/vs/base/browser/ui/actionbar/actionbar.css
+++ b/src/vs/base/browser/ui/actionbar/actionbar.css
@@ -28,10 +28,6 @@
 .monaco-action-bar .action-item {
 	cursor: pointer;
 	display: inline-block;
-	-ms-transition: -ms-transform 50ms ease;
-	-webkit-transition: -webkit-transform 50ms ease;
-	-moz-transition: -moz-transform 50ms ease;
-	-o-transition: -o-transform 50ms ease;
 	transition: transform 50ms ease;
 	position: relative;  /* DO NOT REMOVE - this is the key to preventing the ghosting icon bug in Chrome 42 */
 }
@@ -41,11 +37,7 @@
 }
 
 .monaco-action-bar.animated .action-item.active {
-	-ms-transform: scale(1.272019649, 1.272019649); /* 1.272019649 = √φ */
-	-webkit-transform: scale(1.272019649, 1.272019649);
-	-moz-transform: scale(1.272019649, 1.272019649);
-	-o-transform: scale(1.272019649, 1.272019649);
-	transform: scale(1.272019649, 1.272019649);
+	transform: scale(1.272019649, 1.272019649); /* 1.272019649 = √φ */
 }
 
 .monaco-action-bar .action-item .icon {
@@ -87,10 +79,6 @@
 }
 
 .monaco-action-bar.animated.vertical .action-item.active {
-	-ms-transform: translate(5px, 0);
-	-webkit-transform: translate(5px, 0);
-	-moz-transform: translate(5px, 0);
-	-o-transform: translate(5px, 0);
 	transform: translate(5px, 0);
 }
 
diff --git a/src/vs/base/browser/ui/menu/menu.css b/src/vs/base/browser/ui/menu/menu.css
index 938304b5ef2..63c1860664d 100644
--- a/src/vs/base/browser/ui/menu/menu.css
+++ b/src/vs/base/browser/ui/menu/menu.css
@@ -14,20 +14,12 @@
 
 .monaco-menu .monaco-action-bar.vertical .action-item {
 	padding: 0;
-	-ms-transform: none;
-	-webkit-transform: none;
-	-moz-transform: none;
-	-o-transform: none;
 	transform: none;
 	display: -ms-flexbox;
 	display: flex;
 }
 
 .monaco-menu .monaco-action-bar.vertical .action-item.active {
-	-ms-transform: none;
-	-webkit-transform: none;
-	-moz-transform: none;
-	-o-transform: none;
 	transform: none;
 }
 
diff --git a/src/vs/base/browser/ui/progressbar/progressbar.css b/src/vs/base/browser/ui/progressbar/progressbar.css
index 0546a200cdf..f926530cec4 100644
--- a/src/vs/base/browser/ui/progressbar/progressbar.css
+++ b/src/vs/base/browser/ui/progressbar/progressbar.css
@@ -24,10 +24,6 @@
 .monaco-progress-container.discrete .progress-bit {
 	left: 0;
 	transition: width 100ms linear;
-	-webkit-transition: width 100ms linear;
-	-o-transition: width 100ms linear;
-	-moz-transition: width 100ms linear;
-	-ms-transition: width 100ms linear;
 }
 
 .monaco-progress-container.discrete.done .progress-bit {
diff --git a/src/vs/base/browser/ui/scrollbar/media/scrollbars.css b/src/vs/base/browser/ui/scrollbar/media/scrollbars.css
index aa824d83a2f..b05c77eed8a 100644
--- a/src/vs/base/browser/ui/scrollbar/media/scrollbars.css
+++ b/src/vs/base/browser/ui/scrollbar/media/scrollbars.css
@@ -44,10 +44,6 @@
 	/* Background rule added for IE9 - to allow clicks on dom node */
 	background:rgba(0,0,0,0);
 
-	-webkit-transition: opacity 100ms linear;
-	-o-transition: opacity 100ms linear;
-	-moz-transition: opacity 100ms linear;
-	-ms-transition: opacity 100ms linear;
 	transition: opacity 100ms linear;
 }
 .monaco-scrollable-element > .invisible {
@@ -55,10 +51,6 @@
 	pointer-events: none;
 }
 .monaco-scrollable-element > .invisible.fade {
-	-webkit-transition: opacity 800ms linear;
-	-o-transition: opacity 800ms linear;
-	-moz-transition: opacity 800ms linear;
-	-ms-transition: opacity 800ms linear;
 	transition: opacity 800ms linear;
 }
 
diff --git a/src/vs/base/browser/ui/splitview/panelview.css b/src/vs/base/browser/ui/splitview/panelview.css
index fba60f61621..4801a2bd3a9 100644
--- a/src/vs/base/browser/ui/splitview/panelview.css
+++ b/src/vs/base/browser/ui/splitview/panelview.css
@@ -90,21 +90,13 @@
 
 .monaco-panel-view.animated .split-view-view {
 	transition-duration: 0.15s;
-	-webkit-transition-duration: 0.15s;
-	-moz-transition-duration: 0.15s;
 	transition-timing-function: ease-out;
-	-webkit-transition-timing-function: ease-out;
-	-moz-transition-timing-function: ease-out;
 }
 
 .monaco-panel-view.animated.vertical .split-view-view {
 	transition-property: height;
-	-webkit-transition-property: height;
-	-moz-transition-property: height;
 }
 
 .monaco-panel-view.animated.horizontal .split-view-view {
 	transition-property: width;
-	-webkit-transition-property: width;
-	-moz-transition-property: width;
 }
diff --git a/src/vs/editor/contrib/find/findWidget.css b/src/vs/editor/contrib/find/findWidget.css
index eb838937d58..461ece739b9 100644
--- a/src/vs/editor/contrib/find/findWidget.css
+++ b/src/vs/editor/contrib/find/findWidget.css
@@ -36,13 +36,7 @@
 	height: 34px; /* find input height */
 	overflow: hidden;
 	line-height: 19px;
-
-	-webkit-transition: top 200ms linear;
-	-o-transition: top 200ms linear;
-	-moz-transition: top 200ms linear;
-	-ms-transition: top 200ms linear;
 	transition: top 200ms linear;
-
 	padding: 0 4px;
 }
 /* Find widget when replace is toggled on */
diff --git a/src/vs/editor/contrib/find/simpleFindWidget.css b/src/vs/editor/contrib/find/simpleFindWidget.css
index 9037b26a7fc..cbcf1f1fc8b 100644
--- a/src/vs/editor/contrib/find/simpleFindWidget.css
+++ b/src/vs/editor/contrib/find/simpleFindWidget.css
@@ -22,11 +22,6 @@
 	padding: 4px;
 	align-items: center;
 	pointer-events: all;
-
-	-webkit-transition: top 200ms linear;
-	-o-transition: top 200ms linear;
-	-moz-transition: top 200ms linear;
-	-ms-transition: top 200ms linear;
 	transition: top 200ms linear;
 }
 
diff --git a/src/vs/editor/contrib/parameterHints/parameterHints.css b/src/vs/editor/contrib/parameterHints/parameterHints.css
index c65b3e07e8d..625740080a7 100644
--- a/src/vs/editor/contrib/parameterHints/parameterHints.css
+++ b/src/vs/editor/contrib/parameterHints/parameterHints.css
@@ -22,9 +22,6 @@
 }
 
 .monaco-editor .parameter-hints-widget.visible {
-	-webkit-transition: left .05s ease-in-out;
-	-moz-transition: left .05s ease-in-out;
-	-o-transition: left .05s ease-in-out;
 	transition: left .05s ease-in-out;
 }
 
diff --git a/src/vs/workbench/parts/debug/browser/media/debugViewlet.css b/src/vs/workbench/parts/debug/browser/media/debugViewlet.css
index 48ab4d9099a..1f760b93e71 100644
--- a/src/vs/workbench/parts/debug/browser/media/debugViewlet.css
+++ b/src/vs/workbench/parts/debug/browser/media/debugViewlet.css
@@ -72,7 +72,6 @@
 	background-position: center center;
 	flex-shrink: 0;
 	transition: transform 50ms ease;
-	-webkit-transition: -webkit-transform 50ms ease;
 }
 
 .vs-dark .monaco-workbench > .part > .title > .title-actions .start-debug-action-item .icon,
@@ -93,7 +92,6 @@
 }
 
 .monaco-workbench > .part > .title > .title-actions .start-debug-action-item .icon.active {
-	-webkit-transform: scale(1.272019649, 1.272019649);
 	transform: scale(1.272019649, 1.272019649);
 }
 

From a342380e896984977fa6a79121c559818dda4c71 Mon Sep 17 00:00:00 2001
From: Marcus Farkas <toothlessgear@finitebox.com>
Date: Sun, 7 Oct 2018 20:58:47 +0200
Subject: [PATCH 19/76] Add setting to allow to disable Replace Preview

Introduces a new settings option "search.useReplacePreview" which
allows you to disable "Replace Preview" during a Search/Replace.

Closes #60027
---
 src/vs/platform/search/common/search.ts                      | 1 +
 src/vs/workbench/parts/search/browser/searchView.ts          | 3 ++-
 .../parts/search/electron-browser/search.contribution.ts     | 5 +++++
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/vs/platform/search/common/search.ts b/src/vs/platform/search/common/search.ts
index 31be8e8fcde..4469a60ea0b 100644
--- a/src/vs/platform/search/common/search.ts
+++ b/src/vs/platform/search/common/search.ts
@@ -282,6 +282,7 @@ export interface ISearchConfigurationProperties {
 	smartCase: boolean;
 	globalFindClipboard: boolean;
 	location: 'sidebar' | 'panel';
+	useReplacePreview: boolean;
 }
 
 export interface ISearchConfiguration extends IFilesConfiguration {
diff --git a/src/vs/workbench/parts/search/browser/searchView.ts b/src/vs/workbench/parts/search/browser/searchView.ts
index 57d08121dbf..de7679300bc 100644
--- a/src/vs/workbench/parts/search/browser/searchView.ts
+++ b/src/vs/workbench/parts/search/browser/searchView.ts
@@ -1402,7 +1402,8 @@ export class SearchView extends Viewlet implements IViewlet, IPanel {
 			return TPromise.as(true);
 		}
 
-		return (this.viewModel.isReplaceActive() && !!this.viewModel.replaceString) ?
+		const useReplacePreview = this.configurationService.getValue<ISearchConfiguration>().search.useReplacePreview;
+		return (useReplacePreview && this.viewModel.isReplaceActive() && !!this.viewModel.replaceString) ?
 			this.replaceService.openReplacePreview(lineMatch, preserveFocus, sideBySide, pinned) :
 			this.open(lineMatch, preserveFocus, sideBySide, pinned);
 	}
diff --git a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
index 3cd8d9f8021..d7ce5846eb6 100644
--- a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
+++ b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
@@ -643,6 +643,11 @@ configurationRegistry.registerConfiguration({
 			],
 			default: 'auto',
 			description: nls.localize('search.collapseAllResults', "Controls whether the search results will be collapsed or expanded."),
+		},
+		'search.useReplacePreview': {
+			type: 'boolean',
+			default: true,
+			description: nls.localize('search.useReplacePreview', "Controls whether to open Replace Preview when replacing a match."),
 		}
 	}
 });

From 00cd0c355bbc5479070bee5604b8fe3d64ae05ad Mon Sep 17 00:00:00 2001
From: Miguel Solorio <miguel.solorio@microsoft.com>
Date: Mon, 8 Oct 2018 08:48:08 -0700
Subject: [PATCH 20/76] Increase max-width for find-widget

---
 src/vs/editor/contrib/find/findWidget.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/editor/contrib/find/findWidget.css b/src/vs/editor/contrib/find/findWidget.css
index 461ece739b9..faf3f7efe98 100644
--- a/src/vs/editor/contrib/find/findWidget.css
+++ b/src/vs/editor/contrib/find/findWidget.css
@@ -247,7 +247,7 @@
 
 /* COLLAPSED (SMALLER THAN NARROW) */
 .monaco-editor .find-widget.collapsed-find-widget {
-	max-width: 111px !important;
+	max-width: 170px !important;
 }
 
 .monaco-editor .find-widget.collapsed-find-widget .button.previous,

From d4f40dd755171447cc1c522f7ce57518bcafba25 Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Mon, 8 Oct 2018 09:14:43 -0700
Subject: [PATCH 21/76] vscode-xterm@3.9.0-beta2

---
 package.json | 2 +-
 yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package.json b/package.json
index e988b55a858..ae860ddb5c1 100644
--- a/package.json
+++ b/package.json
@@ -49,7 +49,7 @@
     "vscode-nsfw": "1.0.17",
     "vscode-ripgrep": "^1.2.2",
     "vscode-textmate": "^4.0.1",
-    "vscode-xterm": "3.9.0-beta1",
+    "vscode-xterm": "3.9.0-beta2",
     "winreg": "^1.2.4",
     "yauzl": "^2.9.1",
     "yazl": "^2.4.3"
diff --git a/yarn.lock b/yarn.lock
index d256989808f..757d51dd7af 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9351,10 +9351,10 @@ vscode-textmate@^4.0.1:
   dependencies:
     oniguruma "^7.0.0"
 
-vscode-xterm@3.9.0-beta1:
-  version "3.9.0-beta1"
-  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta1.tgz#dfe0ff41ee062a9fbcda9eb050dcd9e73fe34278"
-  integrity sha512-PMLI+4n6ysY2VB/6UF9j1OZ8RR4wATc+mdVFb1fEVWI4k6i6mdTNpMrd9U5cLJaswfr+hlql2PQL9EprhuKRNA==
+vscode-xterm@3.9.0-beta2:
+  version "3.9.0-beta2"
+  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta2.tgz#36e6c6b3dee9324343d240acec0bc0af5283e8bd"
+  integrity sha512-v8uPv0UGoOxz6t22l/0uxIdcZVNOldk/5ZNp1zjVW+EBecE/zN4JCY3rAJALpgsTm4XlJZfi0f49yLVeyg3WeA==
 
 vso-node-api@6.1.2-preview:
   version "6.1.2-preview"

From fd52305912e5ad64134f3b942d3d8f2d0ab81ccc Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Mon, 8 Oct 2018 09:15:40 -0700
Subject: [PATCH 22/76] Update xterm types

---
 src/typings/vscode-xterm.d.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/typings/vscode-xterm.d.ts b/src/typings/vscode-xterm.d.ts
index a104e7aee35..2631d806ad2 100644
--- a/src/typings/vscode-xterm.d.ts
+++ b/src/typings/vscode-xterm.d.ts
@@ -89,6 +89,16 @@ declare module 'vscode-xterm' {
 		 */
 		experimentalCharAtlas?: 'none' | 'static' | 'dynamic';
 
+		/**
+		 * (EXPERIMENTAL) Defines which implementation to use for buffer lines.
+		 *
+		 * - 'JsArray': The default/stable implementation.
+		 * - 'TypedArray': The new experimental implementation based on TypedArrays that is expected to
+		 *   significantly boost performance and memory consumption. Use at your own risk.
+		 *
+		 * This option will be removed in the future.
+		 */
+		experimentalBufferLineImpl?: 'JsArray' | 'TypedArray';
 		/**
 		 * The font size used to render text.
 		 */

From a2b1bf32bb524806c560cc530d05ad94cbc310ea Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Mon, 8 Oct 2018 09:33:56 -0700
Subject: [PATCH 23/76] Add terminal.integrated.experimentalBufferImpl setting

Fixes #60155
---
 src/vs/workbench/parts/terminal/common/terminal.ts        | 1 +
 .../terminal/electron-browser/terminal.contribution.ts    | 8 +++++++-
 .../parts/terminal/electron-browser/terminalInstance.ts   | 3 ++-
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/vs/workbench/parts/terminal/common/terminal.ts b/src/vs/workbench/parts/terminal/common/terminal.ts
index 77ad882bbbf..3f698d71998 100644
--- a/src/vs/workbench/parts/terminal/common/terminal.ts
+++ b/src/vs/workbench/parts/terminal/common/terminal.ts
@@ -99,6 +99,7 @@ export interface ITerminalConfiguration {
 		windows: { [key: string]: string };
 	};
 	showExitAlert: boolean;
+	experimentalBufferImpl: 'JsArray' | 'TypedArray';
 }
 
 export interface ITerminalConfigHelper {
diff --git a/src/vs/workbench/parts/terminal/electron-browser/terminal.contribution.ts b/src/vs/workbench/parts/terminal/electron-browser/terminal.contribution.ts
index 747f387527b..4a5d86980b4 100644
--- a/src/vs/workbench/parts/terminal/electron-browser/terminal.contribution.ts
+++ b/src/vs/workbench/parts/terminal/electron-browser/terminal.contribution.ts
@@ -372,7 +372,13 @@ configurationRegistry.registerConfiguration({
 			description: nls.localize('terminal.integrated.showExitAlert', "Controls whether to show the alert \"The terminal process terminated with exit code\" when exit code is non-zero."),
 			type: 'boolean',
 			default: true
-		}
+		},
+		'terminal.integrated.experimentalBufferImpl': {
+			description: nls.localize('terminal.integrated.experimentalBufferImpl', "Controls the terminal's internal buffer implementation. This setting is picked up on terminal creation and will not apply to existing terminals."),
+			type: 'string',
+			enum: ['JsArray', 'TypedArray'],
+			default: 'JsArray'
+		},
 	}
 });
 
diff --git a/src/vs/workbench/parts/terminal/electron-browser/terminalInstance.ts b/src/vs/workbench/parts/terminal/electron-browser/terminalInstance.ts
index 8df176d3cee..68b2f48d4e9 100644
--- a/src/vs/workbench/parts/terminal/electron-browser/terminalInstance.ts
+++ b/src/vs/workbench/parts/terminal/electron-browser/terminalInstance.ts
@@ -302,7 +302,8 @@ export class TerminalInstance implements ITerminalInstance {
 			// TODO: Guess whether to use canvas or dom better
 			rendererType: config.rendererType === 'auto' ? 'canvas' : config.rendererType,
 			// TODO: Remove this once the setting is removed upstream
-			experimentalCharAtlas: 'dynamic'
+			experimentalCharAtlas: 'dynamic',
+			experimentalBufferLineImpl: config.experimentalBufferImpl
 		});
 		if (this._shellLaunchConfig.initialText) {
 			this._xterm.writeln(this._shellLaunchConfig.initialText);

From d0ecfa0ba66bf522ffae18390485d88d35d931a9 Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 09:34:48 -0700
Subject: [PATCH 24/76] Adding pinning tests for vscode-resource in webviews

---
 .../src/singlefolder-tests/webview.test.ts    | 40 +++++++++++++++++--
 1 file changed, 37 insertions(+), 3 deletions(-)

diff --git a/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts b/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
index e4311f57343..3bde493b12b 100644
--- a/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
+++ b/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
@@ -43,7 +43,7 @@ suite('Webview tests', () => {
 	});
 
 	test('webviews should not have scripts enabled by default', async () => {
-		const webview = _register(vscode.window.createWebviewPanel(webviewId, 'title', { viewColumn: vscode.ViewColumn.One }, { }));
+		const webview = _register(vscode.window.createWebviewPanel(webviewId, 'title', { viewColumn: vscode.ViewColumn.One }, {}));
 		const response = Promise.race<any>([
 			getMesssage(webview),
 			new Promise<{}>(resolve => setTimeout(() => resolve({ value: '🎉' }), 1000))
@@ -71,14 +71,14 @@ suite('Webview tests', () => {
 			assert.strictEqual((await response).value, 'first');
 		}
 		{
-			const firstResponse = getMesssage(webview);
+			const response = getMesssage(webview);
 			webview.webview.html = createHtmlDocumentWithBody(/*html*/`
 				<script>
 					const vscode = acquireVsCodeApi();
 					vscode.postMessage({ value: 'second' });
 				</script>`);
 
-			assert.strictEqual((await firstResponse).value, 'second');
+			assert.strictEqual((await response).value, 'second');
 		}
 	});
 
@@ -243,6 +243,40 @@ suite('Webview tests', () => {
 		const secondResponse = await sendRecieveMessage(webview, { type: 'get' });
 		assert.strictEqual(secondResponse.value, 100);
 	});
+
+	test('webviews should only be able to load resources from workspace by default', async () => {
+		const webview = _register(vscode.window.createWebviewPanel(webviewId, 'title', { viewColumn: vscode.ViewColumn.One }, { enableScripts: true }));
+
+		webview.webview.html = createHtmlDocumentWithBody(/*html*/`
+			<script>
+				const vscode = acquireVsCodeApi();
+				window.addEventListener('message', (message) => {
+					const img = document.createElement('img');
+					img.addEventListener('load', () => { vscode.postMessage({ value: true }); });
+					img.addEventListener('error', () => { vscode.postMessage({ value: false }); });
+					img.src = message.data.src;
+					document.body.appendChild(img);
+				});
+			</script>`);
+
+		const workspaceRootUri = vscode.Uri.file(vscode.workspace.rootPath!).with({ scheme: 'vscode-resource' });
+
+		{
+			const imagePath = workspaceRootUri.toString() + '/image.png';
+			const response = sendRecieveMessage(webview, { src: imagePath });
+			assert.strictEqual((await response).value, true);
+		}
+		{
+			const imagePath = workspaceRootUri.toString() + '/no-such-image.png';
+			const response = sendRecieveMessage(webview, { src: imagePath });
+			assert.strictEqual((await response).value, false);
+		}
+		{
+			const imagePath = vscode.Uri.file(join(vscode.workspace.rootPath!, '..', '..', '..', 'resources', 'linux', 'code.png')).with({ scheme: 'vscode-resource' });
+			const response = sendRecieveMessage(webview, { src: imagePath.toString() });
+			assert.strictEqual((await response).value, false);
+		}
+	});
 });
 
 function createHtmlDocumentWithBody(body: string): string {

From 5b03dcd69d98b6540f789868cf4647b6486ed739 Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 10:08:34 -0700
Subject: [PATCH 25/76] Add pinning test for setting localResourceRoots

---
 .../src/singlefolder-tests/webview.test.ts    |  30 ++++++++++++++++++
 .../testWorkspace/sub/image.png               | Bin 0 -> 36726 bytes
 2 files changed, 30 insertions(+)
 create mode 100644 extensions/vscode-api-tests/testWorkspace/sub/image.png

diff --git a/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts b/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
index 3bde493b12b..d211db9565b 100644
--- a/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
+++ b/extensions/vscode-api-tests/src/singlefolder-tests/webview.test.ts
@@ -277,6 +277,36 @@ suite('Webview tests', () => {
 			assert.strictEqual((await response).value, false);
 		}
 	});
+
+	test('webviews should allow overriding allowed resource paths using localResourceRoots', async () => {
+		const webview = _register(vscode.window.createWebviewPanel(webviewId, 'title', { viewColumn: vscode.ViewColumn.One }, {
+			enableScripts: true,
+			localResourceRoots: [vscode.Uri.file(join(vscode.workspace.rootPath!, 'sub'))]
+		}));
+
+		webview.webview.html = createHtmlDocumentWithBody(/*html*/`
+			<script>
+				const vscode = acquireVsCodeApi();
+				window.addEventListener('message', (message) => {
+					const img = document.createElement('img');
+					img.addEventListener('load', () => { vscode.postMessage({ value: true }); });
+					img.addEventListener('error', () => { vscode.postMessage({ value: false }); });
+					img.src = message.data.src;
+					document.body.appendChild(img);
+				});
+			</script>`);
+
+		const workspaceRootUri = vscode.Uri.file(vscode.workspace.rootPath!).with({ scheme: 'vscode-resource' });
+
+		{
+			const response = sendRecieveMessage(webview, { src: workspaceRootUri.toString() + '/sub/image.png' });
+			assert.strictEqual((await response).value, true);
+		}
+		{
+			const response = sendRecieveMessage(webview, { src: workspaceRootUri.toString() + '/image.png' });
+			assert.strictEqual((await response).value, false);
+		}
+	});
 });
 
 function createHtmlDocumentWithBody(body: string): string {
diff --git a/extensions/vscode-api-tests/testWorkspace/sub/image.png b/extensions/vscode-api-tests/testWorkspace/sub/image.png
new file mode 100644
index 0000000000000000000000000000000000000000..ff8b42295dd3078e8336b79f03385de09d68ed33
GIT binary patch
literal 36726
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

literal 0
HcmV?d00001


From 6b2c0d902b003425a495c9236aad56adffd252d5 Mon Sep 17 00:00:00 2001
From: Marcus Farkas <toothlessgear@finitebox.com>
Date: Mon, 8 Oct 2018 19:47:27 +0200
Subject: [PATCH 26/76] Reword description of "search.useReplacePreview"
 setting

---
 .../parts/search/electron-browser/search.contribution.ts        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
index d7ce5846eb6..cacb5c850b3 100644
--- a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
+++ b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
@@ -647,7 +647,7 @@ configurationRegistry.registerConfiguration({
 		'search.useReplacePreview': {
 			type: 'boolean',
 			default: true,
-			description: nls.localize('search.useReplacePreview', "Controls whether to open Replace Preview when replacing a match."),
+			description: nls.localize('search.useReplacePreview', "Controls whether to open Replace Preview when selecting or replacing a match."),
 		}
 	}
 });

From b1a4f3203f599a972806bdd7b933aa8a42c3cc0b Mon Sep 17 00:00:00 2001
From: SteVen Batten <stbatt@microsoft.com>
Date: Mon, 8 Oct 2018 10:48:10 -0700
Subject: [PATCH 27/76] fixes #60067

---
 src/vs/base/browser/ui/actionbar/actionbar.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/vs/base/browser/ui/actionbar/actionbar.ts b/src/vs/base/browser/ui/actionbar/actionbar.ts
index 9a4fb385355..4d25c01ecfd 100644
--- a/src/vs/base/browser/ui/actionbar/actionbar.ts
+++ b/src/vs/base/browser/ui/actionbar/actionbar.ts
@@ -419,6 +419,10 @@ export class ActionBar extends Disposable implements IActionRunner {
 		this._context = options.context;
 		this._actionRunner = this.options.actionRunner;
 
+		if (!this.options.triggerKeys) {
+			this.options.triggerKeys = defaultOptions.triggerKeys;
+		}
+
 		if (!this._actionRunner) {
 			this._actionRunner = new ActionRunner();
 			this._register(this._actionRunner);

From d4f8db74d41ff3f74a1b3743f677097369c75429 Mon Sep 17 00:00:00 2001
From: SteVen Batten <6561887+sbatten@users.noreply.github.com>
Date: Mon, 8 Oct 2018 10:55:34 -0700
Subject: [PATCH 28/76] adding ability to set checked state for menu item at
 registration (#60004)

* adding ability to set checked state for menu item at registration

* address feedback
---
 src/vs/platform/actions/common/actions.ts      |  4 +++-
 .../browser/parts/editor/breadcrumbsControl.ts |  3 ++-
 .../browser/parts/titlebar/menubarControl.ts   | 18 ------------------
 .../electron-browser/toggleMinimap.ts          |  4 +++-
 .../toggleRenderControlCharacter.ts            |  4 +++-
 .../electron-browser/toggleRenderWhitespace.ts |  4 +++-
 .../fileActions.contribution.ts                |  3 ++-
 7 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/src/vs/platform/actions/common/actions.ts b/src/vs/platform/actions/common/actions.ts
index b9807b16522..ea9ccf27ca7 100644
--- a/src/vs/platform/actions/common/actions.ts
+++ b/src/vs/platform/actions/common/actions.ts
@@ -27,6 +27,7 @@ export interface IBaseCommandAction {
 export interface ICommandAction extends IBaseCommandAction {
 	iconLocation?: { dark: URI; light?: URI; };
 	precondition?: ContextKeyExpr;
+	toggled?: ContextKeyExpr;
 }
 
 export interface ISerializableCommandAction extends IBaseCommandAction {
@@ -220,7 +221,6 @@ export class ExecuteCommandAction extends Action {
 }
 
 export class SubmenuItemAction extends Action {
-	// private _options: IMenuActionOptions;
 
 	readonly item: ISubmenuItem;
 	constructor(item: ISubmenuItem) {
@@ -246,6 +246,8 @@ export class MenuItemAction extends ExecuteCommandAction {
 		typeof item.title === 'string' ? super(item.id, item.title, commandService) : super(item.id, item.title.value, commandService);
 		this._cssClass = undefined;
 		this._enabled = !item.precondition || contextKeyService.contextMatchesRules(item.precondition);
+		this._checked = item.toggled && contextKeyService.contextMatchesRules(item.toggled);
+
 		this._options = options || {};
 
 		this.item = item;
diff --git a/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts b/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
index 28ed4f7fc3d..515593ff365 100644
--- a/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
+++ b/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
@@ -458,7 +458,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
 	order: 99,
 	command: {
 		id: 'breadcrumbs.toggle',
-		title: localize('miToggleBreadcrumbs', "Toggle &&Breadcrumbs")
+		title: localize('miToggleBreadcrumbs', "Toggle &&Breadcrumbs"),
+		toggled: ContextKeyExpr.equals('config.breadcrumbs.enabled', true)
 	}
 });
 CommandsRegistry.registerCommand('breadcrumbs.toggle', accessor => {
diff --git a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
index 3c0365e9418..260eaa4b47c 100644
--- a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
+++ b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
@@ -179,10 +179,6 @@ export class MenubarControl extends Disposable {
 		return enableMenuBarMnemonics;
 	}
 
-	private get currentAutoSaveSetting(): string {
-		return this.configurationService.getValue<string>('files.autoSave');
-	}
-
 	private get currentSidebarPosition(): string {
 		return this.configurationService.getValue<string>('workbench.sideBar.location');
 	}
@@ -485,17 +481,6 @@ export class MenubarControl extends Disposable {
 		this.mnemonics.set(KeyCodeUtils.fromString(mnemonic), menuIndex);
 	}
 
-	private setCheckedStatus(action: IAction | IMenubarMenuItemAction) {
-		switch (action.id) {
-			case 'workbench.action.toggleAutoSave':
-				action.checked = this.currentAutoSaveSetting !== 'off';
-				break;
-
-			default:
-				break;
-		}
-	}
-
 	private calculateActionLabel(action: IAction | IMenubarMenuItemAction): string {
 		let label = action.label;
 		switch (action.id) {
@@ -717,7 +702,6 @@ export class MenubarControl extends Disposable {
 							target.push(new SubmenuAction(action.label, submenuActions));
 						} else {
 							action.label = this.calculateActionLabel(action);
-							this.setCheckedStatus(action);
 							target.push(action);
 						}
 					}
@@ -987,9 +971,7 @@ export class MenubarControl extends Disposable {
 						keybinding: this.getMenubarKeybinding(menuItem.id)
 					};
 
-					this.setCheckedStatus(menubarMenuItem);
 					menubarMenuItem.label = this.calculateActionLabel(menubarMenuItem);
-
 					menuToPopulate.items.push(menubarMenuItem);
 				}
 			});
diff --git a/src/vs/workbench/parts/codeEditor/electron-browser/toggleMinimap.ts b/src/vs/workbench/parts/codeEditor/electron-browser/toggleMinimap.ts
index dd032a17ec2..0b7cf367959 100644
--- a/src/vs/workbench/parts/codeEditor/electron-browser/toggleMinimap.ts
+++ b/src/vs/workbench/parts/codeEditor/electron-browser/toggleMinimap.ts
@@ -9,6 +9,7 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actions';
 import { Action } from 'vs/base/common/actions';
 import { SyncActionDescriptor, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 
 export class ToggleMinimapAction extends Action {
 	public static readonly ID = 'editor.action.toggleMinimap';
@@ -35,7 +36,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
 	group: '5_editor',
 	command: {
 		id: ToggleMinimapAction.ID,
-		title: nls.localize({ key: 'miToggleMinimap', comment: ['&& denotes a mnemonic'] }, "Toggle &&Minimap")
+		title: nls.localize({ key: 'miToggleMinimap', comment: ['&& denotes a mnemonic'] }, "Toggle &&Minimap"),
+		toggled: ContextKeyExpr.equals('config.editor.minimap.enabled', true)
 	},
 	order: 2
 });
diff --git a/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderControlCharacter.ts b/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderControlCharacter.ts
index f7f7e580297..e0e854880ff 100644
--- a/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderControlCharacter.ts
+++ b/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderControlCharacter.ts
@@ -9,6 +9,7 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actions';
 import { Action } from 'vs/base/common/actions';
 import { SyncActionDescriptor, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 
 export class ToggleRenderControlCharacterAction extends Action {
 
@@ -36,7 +37,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
 	group: '5_editor',
 	command: {
 		id: ToggleRenderControlCharacterAction.ID,
-		title: nls.localize({ key: 'miToggleRenderControlCharacters', comment: ['&& denotes a mnemonic'] }, "Toggle &&Control Characters")
+		title: nls.localize({ key: 'miToggleRenderControlCharacters', comment: ['&& denotes a mnemonic'] }, "Toggle &&Control Characters"),
+		toggled: ContextKeyExpr.equals('config.editor.renderControlCharacters', true)
 	},
 	order: 4
 });
diff --git a/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderWhitespace.ts b/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderWhitespace.ts
index 8b3f0bf808e..b6d0bc806eb 100644
--- a/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderWhitespace.ts
+++ b/src/vs/workbench/parts/codeEditor/electron-browser/toggleRenderWhitespace.ts
@@ -9,6 +9,7 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actions';
 import { Action } from 'vs/base/common/actions';
 import { SyncActionDescriptor, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 
 export class ToggleRenderWhitespaceAction extends Action {
 
@@ -44,7 +45,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
 	group: '5_editor',
 	command: {
 		id: ToggleRenderWhitespaceAction.ID,
-		title: nls.localize({ key: 'miToggleRenderWhitespace', comment: ['&& denotes a mnemonic'] }, "Toggle &&Render Whitespace")
+		title: nls.localize({ key: 'miToggleRenderWhitespace', comment: ['&& denotes a mnemonic'] }, "Toggle &&Render Whitespace"),
+		toggled: ContextKeyExpr.notEquals('config.editor.renderWhitespace', 'none')
 	},
 	order: 3
 });
diff --git a/src/vs/workbench/parts/files/electron-browser/fileActions.contribution.ts b/src/vs/workbench/parts/files/electron-browser/fileActions.contribution.ts
index 6f49cecc5bd..0e1d9d3b494 100644
--- a/src/vs/workbench/parts/files/electron-browser/fileActions.contribution.ts
+++ b/src/vs/workbench/parts/files/electron-browser/fileActions.contribution.ts
@@ -555,7 +555,8 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
 	group: '5_autosave',
 	command: {
 		id: ToggleAutoSaveAction.ID,
-		title: nls.localize({ key: 'miAutoSave', comment: ['&& denotes a mnemonic'] }, "A&&uto Save")
+		title: nls.localize({ key: 'miAutoSave', comment: ['&& denotes a mnemonic'] }, "A&&uto Save"),
+		toggled: ContextKeyExpr.notEquals('config.files.autoSave', 'off')
 	},
 	order: 1
 });

From ab8bc96039222acfb2b8d35727ef1b0bb577136a Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Mon, 8 Oct 2018 11:03:00 -0700
Subject: [PATCH 29/76] Stabilize active terminal APIs

Fixes #58357
---
 src/vs/vscode.d.ts                            | 13 +++++++++++++
 src/vs/vscode.proposed.d.ts                   | 13 -------------
 src/vs/workbench/api/node/extHost.api.impl.ts |  6 +++---
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/vs/vscode.d.ts b/src/vs/vscode.d.ts
index 13b07a2fc06..1acd83a8262 100644
--- a/src/vs/vscode.d.ts
+++ b/src/vs/vscode.d.ts
@@ -5920,6 +5920,19 @@ declare module 'vscode' {
 		 */
 		export const terminals: ReadonlyArray<Terminal>;
 
+		/**
+		 * The currently active terminal or `undefined`. The active terminal is the one that
+		 * currently has focus or most recently had focus.
+		 */
+		export const activeTerminal: Terminal | undefined;
+
+		/**
+		 * An [event](#Event) which fires when the [active terminal](#window.activeTerminal)
+		 * has changed. *Note* that the event also fires when the active terminal changes
+		 * to `undefined`.
+		 */
+		export const onDidChangeActiveTerminal: Event<Terminal | undefined>;
+
 		/**
 		 * An [event](#Event) which fires when a terminal has been created, either through the
 		 * [createTerminal](#window.createTerminal) API or commands.
diff --git a/src/vs/vscode.proposed.d.ts b/src/vs/vscode.proposed.d.ts
index c16a02dd272..18714234e9d 100644
--- a/src/vs/vscode.proposed.d.ts
+++ b/src/vs/vscode.proposed.d.ts
@@ -995,19 +995,6 @@ declare module 'vscode' {
 	}
 
 	export namespace window {
-		/**
-		 * The currently active terminal or `undefined`. The active terminal is the one that
-		 * currently has focus or most recently had focus.
-		 */
-		export const activeTerminal: Terminal | undefined;
-
-		/**
-		 * An [event](#Event) which fires when the [active terminal](#window.activeTerminal)
-		 * has changed. *Note* that the event also fires when the active terminal changes
-		 * to `undefined`.
-		 */
-		export const onDidChangeActiveTerminal: Event<Terminal | undefined>;
-
 		/**
 		 * Create a [TerminalRenderer](#TerminalRenderer).
 		 *
diff --git a/src/vs/workbench/api/node/extHost.api.impl.ts b/src/vs/workbench/api/node/extHost.api.impl.ts
index a4ba38dd2ae..f625545fdf4 100644
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -354,7 +354,7 @@ export function createApiFactory(
 				return extHostEditors.getVisibleTextEditors();
 			},
 			get activeTerminal() {
-				return proposedApiFunction(extension, extHostTerminalService.activeTerminal);
+				return extHostTerminalService.activeTerminal;
 			},
 			get terminals() {
 				return extHostTerminalService.terminals;
@@ -397,9 +397,9 @@ export function createApiFactory(
 			onDidOpenTerminal(listener, thisArg?, disposables?) {
 				return extHostTerminalService.onDidOpenTerminal(listener, thisArg, disposables);
 			},
-			onDidChangeActiveTerminal: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
+			onDidChangeActiveTerminal(listener, thisArg?, disposables?) {
 				return extHostTerminalService.onDidChangeActiveTerminal(listener, thisArg, disposables);
-			}),
+			},
 			get state() {
 				return extHostWindow.state;
 			},

From 09afa054eed0b027639f98a7434c20c78cc170a2 Mon Sep 17 00:00:00 2001
From: SteVen Batten <6561887+sbatten@users.noreply.github.com>
Date: Mon, 8 Oct 2018 11:24:42 -0700
Subject: [PATCH 30/76] fix undo, redo, selectAll on macOS (#60040)

---
 .../platform/menubar/electron-main/menubar.ts | 43 ++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/vs/platform/menubar/electron-main/menubar.ts b/src/vs/platform/menubar/electron-main/menubar.ts
index 1a518e18a0f..840ec4d0659 100644
--- a/src/vs/platform/menubar/electron-main/menubar.ts
+++ b/src/vs/platform/menubar/electron-main/menubar.ts
@@ -25,6 +25,11 @@ import { IStateService } from 'vs/platform/state/common/state';
 
 const telemetryFrom = 'menu';
 
+interface IMenuItemClickHandler {
+	inDevTools: (contents: Electron.WebContents) => void;
+	inNoWindow: () => void;
+}
+
 export class Menubar {
 
 	private static readonly MAX_MENU_RECENT_ENTRIES = 10;
@@ -634,8 +639,8 @@ export class Menubar {
 			commandId = arg2[0];
 		}
 
-		// Add role for special case menu items
 		if (isMacintosh) {
+			// Add role for special case menu items
 			if (commandId === 'editor.action.clipboardCutAction') {
 				options['role'] = 'cut';
 			} else if (commandId === 'editor.action.clipboardCopyAction') {
@@ -643,11 +648,47 @@ export class Menubar {
 			} else if (commandId === 'editor.action.clipboardPasteAction') {
 				options['role'] = 'paste';
 			}
+
+			// Add context aware click handlers for special case menu items
+			if (commandId === 'undo') {
+				options.click = this.makeContextAwareClickHandler(click, {
+					inDevTools: devTools => devTools.undo(),
+					inNoWindow: () => Menu.sendActionToFirstResponder('undo:')
+				});
+			} else if (commandId === 'redo') {
+				options.click = this.makeContextAwareClickHandler(click, {
+					inDevTools: devTools => devTools.redo(),
+					inNoWindow: () => Menu.sendActionToFirstResponder('redo:')
+				});
+			} else if (commandId === 'editor.action.selectAll') {
+				options.click = this.makeContextAwareClickHandler(click, {
+					inDevTools: devTools => devTools.selectAll(),
+					inNoWindow: () => Menu.sendActionToFirstResponder('selectAll:')
+				});
+			}
 		}
 
 		return new MenuItem(this.withKeybinding(commandId, options));
 	}
 
+	private makeContextAwareClickHandler(click: () => void, contextSpecificHandlers: IMenuItemClickHandler): () => void {
+		return () => {
+			// No Active Window
+			const activeWindow = this.windowsMainService.getFocusedWindow();
+			if (!activeWindow) {
+				return contextSpecificHandlers.inNoWindow();
+			}
+
+			// DevTools focused
+			if (activeWindow.win.webContents.isDevToolsFocused()) {
+				return contextSpecificHandlers.inDevTools(activeWindow.win.webContents.devToolsWebContents);
+			}
+
+			// Finally execute command in Window
+			click();
+		};
+	}
+
 	private runActionInRenderer(id: string): void {
 		// We make sure to not run actions when the window has no focus, this helps
 		// for https://github.com/Microsoft/vscode/issues/25907 and specifically for

From 5f5488ce75a4d29024521217cbc494be5e9f3745 Mon Sep 17 00:00:00 2001
From: Marcus Farkas <toothlessgear@finitebox.com>
Date: Mon, 8 Oct 2018 22:13:11 +0200
Subject: [PATCH 31/76] Consider "search.useReplacePreview" setting in
 ReplaceAction

---
 src/vs/workbench/parts/search/browser/searchActions.ts | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/vs/workbench/parts/search/browser/searchActions.ts b/src/vs/workbench/parts/search/browser/searchActions.ts
index d0d3026d3d8..6921c98e215 100644
--- a/src/vs/workbench/parts/search/browser/searchActions.ts
+++ b/src/vs/workbench/parts/search/browser/searchActions.ts
@@ -18,7 +18,7 @@ import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService
 import { ICommandHandler } from 'vs/platform/commands/common/commands';
 import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
-import { ISearchHistoryService, VIEW_ID } from 'vs/platform/search/common/search';
+import { ISearchHistoryService, VIEW_ID, ISearchConfiguration } from 'vs/platform/search/common/search';
 import { SearchView } from 'vs/workbench/parts/search/browser/searchView';
 import * as Constants from 'vs/workbench/parts/search/common/constants';
 import { IReplaceService } from 'vs/workbench/parts/search/common/replace';
@@ -28,6 +28,7 @@ import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
 import { normalize } from 'vs/base/common/paths';
 import { IEditorGroupsService } from 'vs/workbench/services/group/common/editorGroupsService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 
 export function isSearchViewFocused(viewletService: IViewletService, panelService: IPanelService): boolean {
 	let searchView = getSearchView(viewletService, panelService);
@@ -561,7 +562,8 @@ export class ReplaceAction extends AbstractSearchAndReplaceAction {
 	constructor(private viewer: ITree, private element: Match, private viewlet: SearchView,
 		@IReplaceService private replaceService: IReplaceService,
 		@IKeybindingService keyBindingService: IKeybindingService,
-		@IEditorService private editorService: IEditorService) {
+		@IEditorService private editorService: IEditorService,
+		@IConfigurationService private configurationService: IConfigurationService) {
 		super(Constants.ReplaceActionId, appendKeyBindingLabel(ReplaceAction.LABEL, keyBindingService.lookupKeybinding(Constants.ReplaceActionId), keyBindingService), 'action-replace');
 	}
 
@@ -575,7 +577,9 @@ export class ReplaceAction extends AbstractSearchAndReplaceAction {
 			}
 			let elementToShowReplacePreview = this.getElementToShowReplacePreview(elementToFocus);
 			this.viewer.domFocus();
-			if (!elementToShowReplacePreview || this.hasToOpenFile()) {
+
+			const useReplacePreview = this.configurationService.getValue<ISearchConfiguration>().search.useReplacePreview;
+			if (!useReplacePreview || !elementToShowReplacePreview || this.hasToOpenFile()) {
 				this.viewlet.open(this.element, true);
 			} else {
 				this.replaceService.openReplacePreview(elementToShowReplacePreview, true);

From f516d17267d9349e71dc744f8e1799fc5e40ff56 Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 15:17:56 -0700
Subject: [PATCH 32/76] Add support for TS RenameTextSpan

Fixes #60204
---
 .../src/features/rename.ts                           | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/extensions/typescript-language-features/src/features/rename.ts b/extensions/typescript-language-features/src/features/rename.ts
index 3547b15d508..683869054ab 100644
--- a/extensions/typescript-language-features/src/features/rename.ts
+++ b/extensions/typescript-language-features/src/features/rename.ts
@@ -11,6 +11,13 @@ import { ITypeScriptServiceClient, ServerResponse } from '../typescriptService';
 import API from '../utils/api';
 import * as typeConverters from '../utils/typeConverters';
 
+// TODO: Remove when we pick up TS 3.2
+declare module '../protocol' {
+	interface RenameTextSpan extends TextSpan {
+		readonly prefixText?: string;
+		readonly suffixText?: string;
+	}
+}
 
 const localize = nls.loadMessageBundle();
 
@@ -102,8 +109,9 @@ class TypeScriptRenameProvider implements vscode.RenameProvider {
 		for (const spanGroup of locations) {
 			const resource = this.client.toResource(spanGroup.file);
 			if (resource) {
-				for (const textSpan of spanGroup.locs) {
-					edit.replace(resource, typeConverters.Range.fromTextSpan(textSpan), newName);
+				for (const textSpan of spanGroup.locs as Proto.RenameTextSpan[]) {
+					edit.replace(resource, typeConverters.Range.fromTextSpan(textSpan),
+						(textSpan.prefixText || '') + newName + (textSpan.suffixText || ''));
 				}
 			}
 		}

From 0cfe8a1d7e7ce60a906ff5efdebb0c85915f8fec Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 15:24:11 -0700
Subject: [PATCH 33/76] Fix potential TSC error

---
 extensions/typescript-language-features/src/features/rename.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extensions/typescript-language-features/src/features/rename.ts b/extensions/typescript-language-features/src/features/rename.ts
index 683869054ab..8d0ceeeff77 100644
--- a/extensions/typescript-language-features/src/features/rename.ts
+++ b/extensions/typescript-language-features/src/features/rename.ts
@@ -13,7 +13,7 @@ import * as typeConverters from '../utils/typeConverters';
 
 // TODO: Remove when we pick up TS 3.2
 declare module '../protocol' {
-	interface RenameTextSpan extends TextSpan {
+	interface RenameTextSpan extends Proto.TextSpan {
 		readonly prefixText?: string;
 		readonly suffixText?: string;
 	}

From 7d95e3e5f9ff8b3be98e3c43e06078a7489558b1 Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 15:51:29 -0700
Subject: [PATCH 34/76] Support markdown link navigation when duplicate slugs
 exist

Fixes #59711

For a md document:

```md
# a

# a

- [a](#a)
- [next a](#a-1)
```

You can now click on the second link in the editor to navigate to the second `a` header. It is identified by being suffixed with `-1`.
---
 .../src/tableOfContentsProvider.ts            | 14 ++++++++++++-
 .../src/test/tableOfContentsProvider.test.ts  | 21 +++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/extensions/markdown-language-features/src/tableOfContentsProvider.ts b/extensions/markdown-language-features/src/tableOfContentsProvider.ts
index 944fc750734..bbb30b7cea6 100644
--- a/extensions/markdown-language-features/src/tableOfContentsProvider.ts
+++ b/extensions/markdown-language-features/src/tableOfContentsProvider.ts
@@ -51,11 +51,23 @@ export class TableOfContentsProvider {
 		const toc: TocEntry[] = [];
 		const tokens = await this.engine.parse(document.uri, document.getText());
 
+		const slugCount = new Map<string, number>();
+
 		for (const heading of tokens.filter(token => token.type === 'heading_open')) {
 			const lineNumber = heading.map[0];
 			const line = document.lineAt(lineNumber);
+
+			let slug = githubSlugifier.fromHeading(line.text);
+			if (slugCount.has(slug.value)) {
+				const count = slugCount.get(slug.value)!;
+				slugCount.set(slug.value, count + 1);
+				slug = githubSlugifier.fromHeading(slug.value + '-' + (count + 1));
+			} else {
+				slugCount.set(slug.value, 0);
+			}
+
 			toc.push({
-				slug: githubSlugifier.fromHeading(line.text),
+				slug,
 				text: TableOfContentsProvider.getHeaderText(line.text),
 				level: TableOfContentsProvider.getHeaderLevel(heading.markup),
 				line: lineNumber,
diff --git a/extensions/markdown-language-features/src/test/tableOfContentsProvider.test.ts b/extensions/markdown-language-features/src/test/tableOfContentsProvider.test.ts
index ee103b294ca..91e12f278a5 100644
--- a/extensions/markdown-language-features/src/test/tableOfContentsProvider.test.ts
+++ b/extensions/markdown-language-features/src/test/tableOfContentsProvider.test.ts
@@ -106,4 +106,25 @@ suite('markdown.TableOfContentsProvider', () => {
 		assert.strictEqual((await provider.lookup('Заголовок-header-3'))!.line, 4);
 		assert.strictEqual((await provider.lookup('Заголовок'))!.line, 5);
 	});
+
+	test('Lookup should support suffixes for repeated headers', async () => {
+		const doc = new InMemoryDocument(testFileName, `# a\n# a\n## a`);
+		const provider = new TableOfContentsProvider(createNewMarkdownEngine(), doc);
+
+		{
+			const entry = await provider.lookup('a');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 0);
+		}
+		{
+			const entry = await provider.lookup('a-1');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 1);
+		}
+		{
+			const entry = await provider.lookup('a-2');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 2);
+		}
+	});
 });

From 9e017425b3d38cfc2d31a7375a28ff6d833ea4ae Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Mon, 8 Oct 2018 16:04:47 -0700
Subject: [PATCH 35/76] Replace markdown-named-headers with custom version

Fixes #47537

Use our own version of markdown named headers. This fixes some bugs around handling duplicate headers
---
 .../markdown-language-features/package.json   |  1 -
 .../src/markdownEngine.ts                     | 35 ++++++++++++++++---
 .../markdown-language-features/yarn.lock      | 12 -------
 3 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/extensions/markdown-language-features/package.json b/extensions/markdown-language-features/package.json
index ee9484ad6c9..dc1a07ae6b0 100644
--- a/extensions/markdown-language-features/package.json
+++ b/extensions/markdown-language-features/package.json
@@ -308,7 +308,6 @@
 	"dependencies": {
 		"highlight.js": "9.12.0",
 		"markdown-it": "^8.4.1",
-		"markdown-it-named-headers": "0.0.4",
 		"vscode-extension-telemetry": "0.0.22",
 		"vscode-nls": "^4.0.0"
 	},
diff --git a/extensions/markdown-language-features/src/markdownEngine.ts b/extensions/markdown-language-features/src/markdownEngine.ts
index 909bc760c2f..085b1a5e2eb 100644
--- a/extensions/markdown-language-features/src/markdownEngine.ts
+++ b/extensions/markdown-language-features/src/markdownEngine.ts
@@ -17,8 +17,8 @@ export class MarkdownEngine {
 	private md?: MarkdownIt;
 
 	private firstLine?: number;
-
 	private currentDocument?: vscode.Uri;
+	private _slugCount = new Map<string, number>();
 
 	public constructor(
 		private readonly extensionPreviewResourceProvider: MarkdownContributions,
@@ -36,7 +36,6 @@ export class MarkdownEngine {
 	private async getEngine(resource: vscode.Uri): Promise<MarkdownIt> {
 		if (!this.md) {
 			const hljs = await import('highlight.js');
-			const mdnh = await import('markdown-it-named-headers');
 			this.md = (await import('markdown-it'))({
 				html: true,
 				highlight: (str: string, lang?: string) => {
@@ -54,8 +53,6 @@ export class MarkdownEngine {
 					}
 					return `<code><div>${this.md!.utils.escapeHtml(str)}</div></code>`;
 				}
-			}).use(mdnh, {
-				slugify: (header: string) => this.slugifier.fromHeading(header).value
 			});
 
 			for (const plugin of this.extensionPreviewResourceProvider.markdownItPlugins) {
@@ -71,6 +68,7 @@ export class MarkdownEngine {
 
 			this.addLinkNormalizer(this.md);
 			this.addLinkValidator(this.md);
+			this.addNamedHeaders(this.md);
 		}
 
 		const config = vscode.workspace.getConfiguration('markdown', resource);
@@ -101,6 +99,8 @@ export class MarkdownEngine {
 		}
 		this.currentDocument = document;
 		this.firstLine = offset;
+		this._slugCount = new Map<string, number>();
+
 		const engine = await this.getEngine(document);
 		return engine.render(text);
 	}
@@ -108,6 +108,8 @@ export class MarkdownEngine {
 	public async parse(document: vscode.Uri, source: string): Promise<Token[]> {
 		const { text, offset } = this.stripFrontmatter(source);
 		this.currentDocument = document;
+		this._slugCount = new Map<string, number>();
+
 		const engine = await this.getEngine(document);
 
 		return engine.parse(text, {}).map(token => {
@@ -219,4 +221,29 @@ export class MarkdownEngine {
 			return validateLink(link) || link.indexOf('file:') === 0;
 		};
 	}
+
+	private addNamedHeaders(md: any): void {
+		const original = md.renderer.rules.heading_open;
+		md.renderer.rules.heading_open = (tokens: any, idx: number, options: any, env: any, self: any) => {
+			const title = tokens[idx + 1].children.reduce((acc: string, t: any) => acc + t.content, '');
+			let slug = this.slugifier.fromHeading(title);
+
+			if (this._slugCount.has(slug.value)) {
+				const count = this._slugCount.get(slug.value)!;
+				this._slugCount.set(slug.value, count + 1);
+				slug = this.slugifier.fromHeading(slug.value + '-' + (count + 1));
+			} else {
+				this._slugCount.set(slug.value, 0);
+			}
+
+			tokens[idx].attrs = tokens[idx].attrs || [];
+			tokens[idx].attrs.push(['id', slug.value]);
+
+			if (original) {
+				return original(tokens, idx, options, env, self);
+			} else {
+				return self.renderToken(tokens, idx, options, env, self);
+			}
+		};
+	}
 }
\ No newline at end of file
diff --git a/extensions/markdown-language-features/yarn.lock b/extensions/markdown-language-features/yarn.lock
index 2ee630f88b9..e95b79f5238 100644
--- a/extensions/markdown-language-features/yarn.lock
+++ b/extensions/markdown-language-features/yarn.lock
@@ -3895,13 +3895,6 @@ map-visit@^1.0.0:
   dependencies:
     object-visit "^1.0.0"
 
-markdown-it-named-headers@0.0.4:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/markdown-it-named-headers/-/markdown-it-named-headers-0.0.4.tgz#82efc28324240a6b1e77b9aae501771d5f351c1f"
-  integrity sha1-gu/CgyQkCmsed7mq5QF3HV81HB8=
-  dependencies:
-    string "^3.0.1"
-
 markdown-it@^8.4.1:
   version "8.4.1"
   resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-8.4.1.tgz#206fe59b0e4e1b78a7c73250af9b34a4ad0aaf44"
@@ -5711,11 +5704,6 @@ string-width@^2.0.0, string-width@^2.1.0:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
-string@^3.0.1:
-  version "3.3.1"
-  resolved "https://registry.yarnpkg.com/string/-/string-3.3.1.tgz#8d2757ec1c0e6c526796fbb6b14036a4098398b7"
-  integrity sha1-jSdX7BwObFJnlvu2sUA2pAmDmLc=
-
 string_decoder@^1.0.0, string_decoder@~1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.0.3.tgz#0fc67d7c141825de94282dd536bec6b9bce860ab"

From c1100eff93b35dc220ce63e2ed0d5ace54259795 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 08:34:50 +0200
Subject: [PATCH 36/76] disable cached data for extensions #60168

---
 .../services/extensions/electron-browser/extensionHost.ts      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts b/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
index 98612acf46d..bab147b26dc 100644
--- a/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
+++ b/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
@@ -177,7 +177,8 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 						VSCODE_IPC_HOOK_EXTHOST: pipeName,
 						VSCODE_HANDLES_UNCAUGHT_ERRORS: true,
 						VSCODE_LOG_STACK: !this._isExtensionDevTestFromCli && (this._isExtensionDevHost || !this._environmentService.isBuilt || product.quality !== 'stable' || this._environmentService.verbose),
-						VSCODE_LOG_LEVEL: this._environmentService.verbose ? 'trace' : this._environmentService.log
+						VSCODE_LOG_LEVEL: this._environmentService.verbose ? 'trace' : this._environmentService.log,
+						VSCODE_NODE_CACHED_DATA_DIR: ''
 					}),
 					// We only detach the extension host on windows. Linux and Mac orphan by default
 					// and detach under Linux and Mac create another process group.

From 6daba7710a7bbb5fc9f2b246d42949688de71f52 Mon Sep 17 00:00:00 2001
From: Alex Dima <alexdima@microsoft.com>
Date: Tue, 9 Oct 2018 09:23:24 +0200
Subject: [PATCH 37/76] Migrate to native Promise in web worker related code
 (#53526)

---
 src/vs/base/common/worker/simpleWorker.ts     | 83 +++++++++----------
 .../common/services/editorSimpleWorker.ts     | 47 +++++------
 .../common/services/editorWorkerService.ts    | 11 ++-
 .../services/editorWorkerServiceImpl.ts       | 49 ++++++-----
 src/vs/editor/common/services/webWorker.ts    | 17 ++--
 .../parts/output/common/outputLinkComputer.ts |  4 +-
 .../parts/output/common/outputLinkProvider.ts |  3 +-
 7 files changed, 104 insertions(+), 110 deletions(-)

diff --git a/src/vs/base/common/worker/simpleWorker.ts b/src/vs/base/common/worker/simpleWorker.ts
index 7f9293c5927..c55e76ee6f1 100644
--- a/src/vs/base/common/worker/simpleWorker.ts
+++ b/src/vs/base/common/worker/simpleWorker.ts
@@ -5,7 +5,6 @@
 
 import { transformErrorForSerialization } from 'vs/base/common/errors';
 import { Disposable } from 'vs/base/common/lifecycle';
-import { ErrorCallback, TPromise, ValueCallback } from 'vs/base/common/winjs.base';
 import { isWeb } from 'vs/base/common/platform';
 
 const INITIALIZE = '$initialize';
@@ -56,13 +55,13 @@ interface IReplyMessage extends IMessage {
 }
 
 interface IMessageReply {
-	c: ValueCallback;
-	e: ErrorCallback;
+	resolve: (value?: any) => void;
+	reject: (error?: any) => void;
 }
 
 interface IMessageHandler {
 	sendMessage(msg: string): void;
-	handleMessage(method: string, args: any[]): TPromise<any>;
+	handleMessage(method: string, args: any[]): Promise<any>;
 }
 
 class SimpleWorkerProtocol {
@@ -83,15 +82,15 @@ class SimpleWorkerProtocol {
 		this._workerId = workerId;
 	}
 
-	public sendMessage(method: string, args: any[]): TPromise<any> {
+	public sendMessage(method: string, args: any[]): Promise<any> {
 		let req = String(++this._lastSentReq);
 		let reply: IMessageReply = {
-			c: null,
-			e: null
+			resolve: null,
+			reject: null
 		};
-		let result = new TPromise<any>((c, e) => {
-			reply.c = c;
-			reply.e = e;
+		let result = new Promise<any>((resolve, reject) => {
+			reply.resolve = resolve;
+			reply.reject = reject;
 		});
 		this._pendingReplies[req] = reply;
 
@@ -140,11 +139,11 @@ class SimpleWorkerProtocol {
 					err.message = replyMessage.err.message;
 					err.stack = replyMessage.err.stack;
 				}
-				reply.e(err);
+				reply.reject(err);
 				return;
 			}
 
-			reply.c(replyMessage.res);
+			reply.resolve(replyMessage.res);
 			return;
 		}
 
@@ -185,14 +184,14 @@ class SimpleWorkerProtocol {
 export class SimpleWorkerClient<T> extends Disposable {
 
 	private _worker: IWorker;
-	private _onModuleLoaded: TPromise<string[]>;
+	private _onModuleLoaded: Promise<string[]>;
 	private _protocol: SimpleWorkerProtocol;
-	private _lazyProxy: TPromise<T>;
+	private _lazyProxy: Promise<T>;
 
 	constructor(workerFactory: IWorkerFactory, moduleId: string) {
 		super();
 
-		let lazyProxyFulfill: (v: T) => void = null;
+		let lazyProxyResolve: (v: T) => void = null;
 		let lazyProxyReject: (err: any) => void = null;
 
 		this._worker = this._register(workerFactory.create(
@@ -211,9 +210,9 @@ export class SimpleWorkerClient<T> extends Disposable {
 			sendMessage: (msg: string): void => {
 				this._worker.postMessage(msg);
 			},
-			handleMessage: (method: string, args: any[]): TPromise<any> => {
+			handleMessage: (method: string, args: any[]): Promise<any> => {
 				// Intentionally not supporting worker -> main requests
-				return TPromise.as(null);
+				return Promise.resolve(null);
 			}
 		});
 		this._protocol.setWorkerId(this._worker.getId());
@@ -228,9 +227,9 @@ export class SimpleWorkerClient<T> extends Disposable {
 			loaderConfiguration = (<any>self).requirejs.s.contexts._.config;
 		}
 
-		this._lazyProxy = new TPromise<T>((c, e) => {
-			lazyProxyFulfill = c;
-			lazyProxyReject = e;
+		this._lazyProxy = new Promise<T>((resolve, reject) => {
+			lazyProxyResolve = resolve;
+			lazyProxyReject = reject;
 		});
 
 		// Send initialize message
@@ -244,18 +243,18 @@ export class SimpleWorkerClient<T> extends Disposable {
 			for (let i = 0; i < availableMethods.length; i++) {
 				(proxy as any)[availableMethods[i]] = createProxyMethod(availableMethods[i], proxyMethodRequest);
 			}
-			lazyProxyFulfill(proxy);
+			lazyProxyResolve(proxy);
 		}, (e) => {
 			lazyProxyReject(e);
 			this._onError('Worker failed to load ' + moduleId, e);
 		});
 
 		// Create proxy to loaded code
-		let proxyMethodRequest = (method: string, args: any[]): TPromise<any> => {
+		let proxyMethodRequest = (method: string, args: any[]): Promise<any> => {
 			return this._request(method, args);
 		};
 
-		let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => TPromise<any>): Function => {
+		let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => Promise<any>): Function => {
 			return function () {
 				let args = Array.prototype.slice.call(arguments, 0);
 				return proxyMethodRequest(method, args);
@@ -263,15 +262,15 @@ export class SimpleWorkerClient<T> extends Disposable {
 		};
 	}
 
-	public getProxyObject(): TPromise<T> {
+	public getProxyObject(): Promise<T> {
 		return this._lazyProxy;
 	}
 
-	private _request(method: string, args: any[]): TPromise<any> {
-		return new TPromise<any>((c, e) => {
+	private _request(method: string, args: any[]): Promise<any> {
+		return new Promise<any>((resolve, reject) => {
 			this._onModuleLoaded.then(() => {
-				this._protocol.sendMessage(method, args).then(c, e);
-			}, e);
+				this._protocol.sendMessage(method, args).then(resolve, reject);
+			}, reject);
 		});
 	}
 
@@ -300,7 +299,7 @@ export class SimpleWorkerServer {
 			sendMessage: (msg: string): void => {
 				postSerializedMessage(msg);
 			},
-			handleMessage: (method: string, args: any[]): TPromise<any> => this._handleMessage(method, args)
+			handleMessage: (method: string, args: any[]): Promise<any> => this._handleMessage(method, args)
 		});
 	}
 
@@ -308,23 +307,23 @@ export class SimpleWorkerServer {
 		this._protocol.handleMessage(msg);
 	}
 
-	private _handleMessage(method: string, args: any[]): TPromise<any> {
+	private _handleMessage(method: string, args: any[]): Promise<any> {
 		if (method === INITIALIZE) {
 			return this.initialize(<number>args[0], <string>args[1], <any>args[2]);
 		}
 
 		if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
-			return TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
+			return Promise.reject(new Error('Missing requestHandler or method: ' + method));
 		}
 
 		try {
-			return TPromise.as(this._requestHandler[method].apply(this._requestHandler, args));
+			return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));
 		} catch (e) {
-			return TPromise.wrapError(e);
+			return Promise.reject(e);
 		}
 	}
 
-	private initialize(workerId: number, moduleId: string, loaderConfig: any): TPromise<any> {
+	private initialize(workerId: number, moduleId: string, loaderConfig: any): Promise<string[]> {
 		this._protocol.setWorkerId(workerId);
 
 		if (this._requestHandler) {
@@ -335,7 +334,7 @@ export class SimpleWorkerServer {
 					methods.push(prop);
 				}
 			}
-			return TPromise.as(methods);
+			return Promise.resolve(methods);
 		}
 
 		if (loaderConfig) {
@@ -354,11 +353,11 @@ export class SimpleWorkerServer {
 			(<any>self).require.config(loaderConfig);
 		}
 
-		let cc: ValueCallback;
-		let ee: ErrorCallback;
-		let r = new TPromise<any>((c, e) => {
-			cc = c;
-			ee = e;
+		let resolve: (value?: string[]) => void;
+		let reject: (error?: any) => void;
+		let r = new Promise<string[]>((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
 		});
 
 		// Use the global require to be sure to get the global config
@@ -373,8 +372,8 @@ export class SimpleWorkerServer {
 				}
 			}
 
-			cc(methods);
-		}, ee);
+			resolve(methods);
+		}, reject);
 
 		return r;
 	}
diff --git a/src/vs/editor/common/services/editorSimpleWorker.ts b/src/vs/editor/common/services/editorSimpleWorker.ts
index 4f7ec3433c3..c38a201b8b8 100644
--- a/src/vs/editor/common/services/editorSimpleWorker.ts
+++ b/src/vs/editor/common/services/editorSimpleWorker.ts
@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { IRequestHandler } from 'vs/base/common/worker/simpleWorker';
 import { Range, IRange } from 'vs/editor/common/core/range';
@@ -336,7 +335,7 @@ export abstract class BaseEditorSimpleWorker {
 
 	// ---- BEGIN diff --------------------------------------------------------------------------
 
-	public computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.ILineChange[]> {
+	public computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<editorCommon.ILineChange[]> {
 		let original = this._getModel(originalUrl);
 		let modified = this._getModel(modifiedUrl);
 		if (!original || !modified) {
@@ -351,10 +350,10 @@ export abstract class BaseEditorSimpleWorker {
 			shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
 			shouldMakePrettyDiff: true
 		});
-		return TPromise.as(diffComputer.computeDiff());
+		return Promise.resolve(diffComputer.computeDiff());
 	}
 
-	public computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.IChange[]> {
+	public computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<editorCommon.IChange[]> {
 		let original = this._getModel(originalUrl);
 		let modified = this._getModel(modifiedUrl);
 		if (!original || !modified) {
@@ -369,7 +368,7 @@ export abstract class BaseEditorSimpleWorker {
 			shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
 			shouldMakePrettyDiff: true
 		});
-		return TPromise.as(diffComputer.computeDiff());
+		return Promise.resolve(diffComputer.computeDiff());
 	}
 
 	// ---- END diff --------------------------------------------------------------------------
@@ -379,10 +378,10 @@ export abstract class BaseEditorSimpleWorker {
 
 	private static readonly _diffLimit = 10000;
 
-	public computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[]): TPromise<TextEdit[]> {
+	public computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[]): Promise<TextEdit[]> {
 		const model = this._getModel(modelUrl);
 		if (!model) {
-			return TPromise.as(edits);
+			return Promise.resolve(edits);
 		}
 
 		const result: TextEdit[] = [];
@@ -437,25 +436,25 @@ export abstract class BaseEditorSimpleWorker {
 			result.push({ eol: lastEol, text: undefined, range: undefined });
 		}
 
-		return TPromise.as(result);
+		return Promise.resolve(result);
 	}
 
 	// ---- END minimal edits ---------------------------------------------------------------
 
-	public computeLinks(modelUrl: string): TPromise<ILink[]> {
+	public computeLinks(modelUrl: string): Promise<ILink[]> {
 		let model = this._getModel(modelUrl);
 		if (!model) {
 			return null;
 		}
 
-		return TPromise.as(computeLinks(model));
+		return Promise.resolve(computeLinks(model));
 	}
 
 	// ---- BEGIN suggest --------------------------------------------------------------------------
 
 	private static readonly _suggestionsLimit = 10000;
 
-	public textualSuggest(modelUrl: string, position: IPosition, wordDef: string, wordDefFlags: string): TPromise<CompletionList> {
+	public textualSuggest(modelUrl: string, position: IPosition, wordDef: string, wordDefFlags: string): Promise<CompletionList> {
 		const model = this._getModel(modelUrl);
 		if (model) {
 			const suggestions: CompletionItem[] = [];
@@ -488,7 +487,7 @@ export abstract class BaseEditorSimpleWorker {
 				});
 			}
 
-			return TPromise.as({ suggestions });
+			return Promise.resolve({ suggestions });
 		}
 		return undefined;
 	}
@@ -529,7 +528,7 @@ export abstract class BaseEditorSimpleWorker {
 
 	//#endregion
 
-	public navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): TPromise<IInplaceReplaceSupportResult> {
+	public navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): Promise<IInplaceReplaceSupportResult> {
 		let model = this._getModel(modelUrl);
 		if (!model) {
 			return null;
@@ -555,12 +554,12 @@ export abstract class BaseEditorSimpleWorker {
 		}
 
 		let result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
-		return TPromise.as(result);
+		return Promise.resolve(result);
 	}
 
 	// ---- BEGIN foreign module support --------------------------------------------------------------------------
 
-	public loadForeignModule(moduleId: string, createData: any): TPromise<string[]> {
+	public loadForeignModule(moduleId: string, createData: any): Promise<string[]> {
 		let ctx: IWorkerContext = {
 			getMirrorModels: (): IMirrorModel[] => {
 				return this._getModels();
@@ -576,10 +575,10 @@ export abstract class BaseEditorSimpleWorker {
 					methods.push(prop);
 				}
 			}
-			return TPromise.as(methods);
+			return Promise.resolve(methods);
 		}
 		// ESM-comment-begin
-		return new TPromise<any>((c, e) => {
+		return new Promise<any>((resolve, reject) => {
 			require([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {
 				this._foreignModule = foreignModule.create(ctx, createData);
 
@@ -590,27 +589,27 @@ export abstract class BaseEditorSimpleWorker {
 					}
 				}
 
-				c(methods);
+				resolve(methods);
 
-			}, e);
+			}, reject);
 		});
 		// ESM-comment-end
 
 		// ESM-uncomment-begin
-		// return TPromise.wrapError(new Error(`Unexpected usage`));
+		// return Promise.reject(new Error(`Unexpected usage`));
 		// ESM-uncomment-end
 	}
 
 	// foreign method request
-	public fmr(method: string, args: any[]): TPromise<any> {
+	public fmr(method: string, args: any[]): Promise<any> {
 		if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
-			return TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
+			return Promise.reject(new Error('Missing requestHandler or method: ' + method));
 		}
 
 		try {
-			return TPromise.as(this._foreignModule[method].apply(this._foreignModule, args));
+			return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
 		} catch (e) {
-			return TPromise.wrapError(e);
+			return Promise.reject(e);
 		}
 	}
 
diff --git a/src/vs/editor/common/services/editorWorkerService.ts b/src/vs/editor/common/services/editorWorkerService.ts
index 5d96d912bda..ff2fa9eb212 100644
--- a/src/vs/editor/common/services/editorWorkerService.ts
+++ b/src/vs/editor/common/services/editorWorkerService.ts
@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { IChange, ILineChange } from 'vs/editor/common/editorCommon';
 import { IInplaceReplaceSupportResult, TextEdit } from 'vs/editor/common/modes';
@@ -17,16 +16,16 @@ export interface IEditorWorkerService {
 	_serviceBrand: any;
 
 	canComputeDiff(original: URI, modified: URI): boolean;
-	computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<ILineChange[]>;
+	computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<ILineChange[]>;
 
 	canComputeDirtyDiff(original: URI, modified: URI): boolean;
-	computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<IChange[]>;
+	computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[]>;
 
-	computeMoreMinimalEdits(resource: URI, edits: TextEdit[]): TPromise<TextEdit[]>;
+	computeMoreMinimalEdits(resource: URI, edits: TextEdit[]): Promise<TextEdit[]>;
 
 	canComputeWordRanges(resource: URI): boolean;
-	computeWordRanges(resource: URI, range: IRange): TPromise<{ [word: string]: IRange[] }>;
+	computeWordRanges(resource: URI, range: IRange): Promise<{ [word: string]: IRange[] }>;
 
 	canNavigateValueSet(resource: URI): boolean;
-	navigateValueSet(resource: URI, range: IRange, up: boolean): TPromise<IInplaceReplaceSupportResult>;
+	navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<IInplaceReplaceSupportResult>;
 }
diff --git a/src/vs/editor/common/services/editorWorkerServiceImpl.ts b/src/vs/editor/common/services/editorWorkerServiceImpl.ts
index 8b14e5e2412..db899de6fdb 100644
--- a/src/vs/editor/common/services/editorWorkerServiceImpl.ts
+++ b/src/vs/editor/common/services/editorWorkerServiceImpl.ts
@@ -6,7 +6,6 @@
 import { IntervalTimer } from 'vs/base/common/async';
 import { Disposable, IDisposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { SimpleWorkerClient, logOnceWebWorkerWarning } from 'vs/base/common/worker/simpleWorker';
 import { DefaultWorkerFactory } from 'vs/base/worker/defaultWorkerFactory';
 import * as editorCommon from 'vs/editor/common/editorCommon';
@@ -60,7 +59,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		this._register(modes.LinkProviderRegistry.register('*', <modes.LinkProvider>{
 			provideLinks: (model, token) => {
 				if (!canSyncModel(this._modelService, model.uri)) {
-					return TPromise.as([]); // File too large
+					return Promise.resolve([]); // File too large
 				}
 				return this._workerManager.withWorker().then(client => client.computeLinks(model.uri));
 			}
@@ -76,7 +75,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		return (canSyncModel(this._modelService, original) && canSyncModel(this._modelService, modified));
 	}
 
-	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<editorCommon.ILineChange[]> {
+	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<editorCommon.ILineChange[]> {
 		return this._workerManager.withWorker().then(client => client.computeDiff(original, modified, ignoreTrimWhitespace));
 	}
 
@@ -84,16 +83,16 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		return (canSyncModel(this._modelService, original) && canSyncModel(this._modelService, modified));
 	}
 
-	public computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<editorCommon.IChange[]> {
+	public computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<editorCommon.IChange[]> {
 		return this._workerManager.withWorker().then(client => client.computeDirtyDiff(original, modified, ignoreTrimWhitespace));
 	}
 
-	public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[]): TPromise<modes.TextEdit[]> {
+	public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[]): Promise<modes.TextEdit[]> {
 		if (!Array.isArray(edits) || edits.length === 0) {
-			return TPromise.as(edits);
+			return Promise.resolve(edits);
 		} else {
 			if (!canSyncModel(this._modelService, resource)) {
-				return TPromise.as(edits); // File too large
+				return Promise.resolve(edits); // File too large
 			}
 			return this._workerManager.withWorker().then(client => client.computeMoreMinimalEdits(resource, edits));
 		}
@@ -103,7 +102,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		return (canSyncModel(this._modelService, resource));
 	}
 
-	public navigateValueSet(resource: URI, range: IRange, up: boolean): TPromise<modes.IInplaceReplaceSupportResult> {
+	public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<modes.IInplaceReplaceSupportResult> {
 		return this._workerManager.withWorker().then(client => client.navigateValueSet(resource, range, up));
 	}
 
@@ -111,7 +110,7 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		return canSyncModel(this._modelService, resource);
 	}
 
-	computeWordRanges(resource: URI, range: IRange): TPromise<{ [word: string]: IRange[] }> {
+	computeWordRanges(resource: URI, range: IRange): Promise<{ [word: string]: IRange[] }> {
 		return this._workerManager.withWorker().then(client => client.computeWordRanges(resource, range));
 	}
 }
@@ -132,7 +131,7 @@ class WordBasedCompletionItemProvider implements modes.CompletionItemProvider {
 		this._modelService = modelService;
 	}
 
-	provideCompletionItems(model: ITextModel, position: Position): TPromise<modes.CompletionList> {
+	provideCompletionItems(model: ITextModel, position: Position): Promise<modes.CompletionList> {
 		const { wordBasedSuggestions } = this._configurationService.getValue<IEditorOptions>(model.uri, position, 'editor');
 		if (!wordBasedSuggestions) {
 			return undefined;
@@ -200,12 +199,12 @@ class WorkerManager extends Disposable {
 		}
 	}
 
-	public withWorker(): TPromise<EditorWorkerClient> {
+	public withWorker(): Promise<EditorWorkerClient> {
 		this._lastWorkerUsedTime = (new Date()).getTime();
 		if (!this._editorWorkerClient) {
 			this._editorWorkerClient = new EditorWorkerClient(this._modelService, 'editorWorkerService');
 		}
-		return TPromise.as(this._editorWorkerClient);
+		return Promise.resolve(this._editorWorkerClient);
 	}
 }
 
@@ -308,17 +307,17 @@ class EditorModelManager extends Disposable {
 }
 
 interface IWorkerClient<T> {
-	getProxyObject(): TPromise<T>;
+	getProxyObject(): Promise<T>;
 	dispose(): void;
 }
 
 class SynchronousWorkerClient<T extends IDisposable> implements IWorkerClient<T> {
 	private _instance: T;
-	private _proxyObj: TPromise<T>;
+	private _proxyObj: Promise<T>;
 
 	constructor(instance: T) {
 		this._instance = instance;
-		this._proxyObj = TPromise.as(this._instance);
+		this._proxyObj = Promise.resolve(this._instance);
 	}
 
 	public dispose(): void {
@@ -327,7 +326,7 @@ class SynchronousWorkerClient<T extends IDisposable> implements IWorkerClient<T>
 		this._proxyObj = null;
 	}
 
-	public getProxyObject(): TPromise<T> {
+	public getProxyObject(): Promise<T> {
 		return this._proxyObj;
 	}
 }
@@ -362,7 +361,7 @@ export class EditorWorkerClient extends Disposable {
 		return this._worker;
 	}
 
-	protected _getProxy(): TPromise<EditorSimpleWorkerImpl> {
+	protected _getProxy(): Promise<EditorSimpleWorkerImpl> {
 		return this._getOrCreateWorker().getProxyObject().then(null, (err) => {
 			logOnceWebWorkerWarning(err);
 			this._worker = new SynchronousWorkerClient(new EditorSimpleWorkerImpl(null));
@@ -377,38 +376,38 @@ export class EditorWorkerClient extends Disposable {
 		return this._modelManager;
 	}
 
-	protected _withSyncedResources(resources: URI[]): TPromise<EditorSimpleWorkerImpl> {
+	protected _withSyncedResources(resources: URI[]): Promise<EditorSimpleWorkerImpl> {
 		return this._getProxy().then((proxy) => {
 			this._getOrCreateModelManager(proxy).esureSyncedResources(resources);
 			return proxy;
 		});
 	}
 
-	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<editorCommon.ILineChange[]> {
+	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<editorCommon.ILineChange[]> {
 		return this._withSyncedResources([original, modified]).then(proxy => {
 			return proxy.computeDiff(original.toString(), modified.toString(), ignoreTrimWhitespace);
 		});
 	}
 
-	public computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): TPromise<editorCommon.IChange[]> {
+	public computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<editorCommon.IChange[]> {
 		return this._withSyncedResources([original, modified]).then(proxy => {
 			return proxy.computeDirtyDiff(original.toString(), modified.toString(), ignoreTrimWhitespace);
 		});
 	}
 
-	public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[]): TPromise<modes.TextEdit[]> {
+	public computeMoreMinimalEdits(resource: URI, edits: modes.TextEdit[]): Promise<modes.TextEdit[]> {
 		return this._withSyncedResources([resource]).then(proxy => {
 			return proxy.computeMoreMinimalEdits(resource.toString(), edits);
 		});
 	}
 
-	public computeLinks(resource: URI): TPromise<modes.ILink[]> {
+	public computeLinks(resource: URI): Promise<modes.ILink[]> {
 		return this._withSyncedResources([resource]).then(proxy => {
 			return proxy.computeLinks(resource.toString());
 		});
 	}
 
-	public textualSuggest(resource: URI, position: IPosition): TPromise<modes.CompletionList> {
+	public textualSuggest(resource: URI, position: IPosition): Promise<modes.CompletionList> {
 		return this._withSyncedResources([resource]).then(proxy => {
 			let model = this._modelService.getModel(resource);
 			if (!model) {
@@ -421,7 +420,7 @@ export class EditorWorkerClient extends Disposable {
 		});
 	}
 
-	computeWordRanges(resource: URI, range: IRange): TPromise<{ [word: string]: IRange[] }> {
+	computeWordRanges(resource: URI, range: IRange): Promise<{ [word: string]: IRange[] }> {
 		return this._withSyncedResources([resource]).then(proxy => {
 			let model = this._modelService.getModel(resource);
 			if (!model) {
@@ -434,7 +433,7 @@ export class EditorWorkerClient extends Disposable {
 		});
 	}
 
-	public navigateValueSet(resource: URI, range: IRange, up: boolean): TPromise<modes.IInplaceReplaceSupportResult> {
+	public navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<modes.IInplaceReplaceSupportResult> {
 		return this._withSyncedResources([resource]).then(proxy => {
 			let model = this._modelService.getModel(resource);
 			if (!model) {
diff --git a/src/vs/editor/common/services/webWorker.ts b/src/vs/editor/common/services/webWorker.ts
index 9646331f279..f0c97ae56a4 100644
--- a/src/vs/editor/common/services/webWorker.ts
+++ b/src/vs/editor/common/services/webWorker.ts
@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { EditorWorkerClient } from 'vs/editor/common/services/editorWorkerServiceImpl';
 
@@ -27,12 +26,12 @@ export interface MonacoWebWorker<T> {
 	/**
 	 * Get a proxy to the arbitrary loaded code.
 	 */
-	getProxy(): TPromise<T>;
+	getProxy(): Promise<T>;
 	/**
 	 * Synchronize (send) the models at `resources` to the web worker,
 	 * making them available in the monaco.worker.getMirrorModels().
 	 */
-	withSyncedResources(resources: URI[]): TPromise<T>;
+	withSyncedResources(resources: URI[]): Promise<T>;
 }
 
 export interface IWebWorkerOptions {
@@ -55,7 +54,7 @@ class MonacoWebWorkerImpl<T> extends EditorWorkerClient implements MonacoWebWork
 
 	private _foreignModuleId: string;
 	private _foreignModuleCreateData: any;
-	private _foreignProxy: TPromise<T>;
+	private _foreignProxy: Promise<T>;
 
 	constructor(modelService: IModelService, opts: IWebWorkerOptions) {
 		super(modelService, opts.label);
@@ -64,18 +63,18 @@ class MonacoWebWorkerImpl<T> extends EditorWorkerClient implements MonacoWebWork
 		this._foreignProxy = null;
 	}
 
-	private _getForeignProxy(): TPromise<T> {
+	private _getForeignProxy(): Promise<T> {
 		if (!this._foreignProxy) {
 			this._foreignProxy = this._getProxy().then((proxy) => {
 				return proxy.loadForeignModule(this._foreignModuleId, this._foreignModuleCreateData).then((foreignMethods) => {
 					this._foreignModuleId = null;
 					this._foreignModuleCreateData = null;
 
-					let proxyMethodRequest = (method: string, args: any[]): TPromise<any> => {
+					let proxyMethodRequest = (method: string, args: any[]): Promise<any> => {
 						return proxy.fmr(method, args);
 					};
 
-					let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => TPromise<any>): Function => {
+					let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => Promise<any>): Function => {
 						return function () {
 							let args = Array.prototype.slice.call(arguments, 0);
 							return proxyMethodRequest(method, args);
@@ -94,11 +93,11 @@ class MonacoWebWorkerImpl<T> extends EditorWorkerClient implements MonacoWebWork
 		return this._foreignProxy;
 	}
 
-	public getProxy(): TPromise<T> {
+	public getProxy(): Promise<T> {
 		return this._getForeignProxy();
 	}
 
-	public withSyncedResources(resources: URI[]): TPromise<T> {
+	public withSyncedResources(resources: URI[]): Promise<T> {
 		return this._withSyncedResources(resources).then(_ => this.getProxy());
 	}
 }
diff --git a/src/vs/workbench/parts/output/common/outputLinkComputer.ts b/src/vs/workbench/parts/output/common/outputLinkComputer.ts
index fa043755526..081ab8a0da7 100644
--- a/src/vs/workbench/parts/output/common/outputLinkComputer.ts
+++ b/src/vs/workbench/parts/output/common/outputLinkComputer.ts
@@ -55,7 +55,7 @@ export class OutputLinkComputer {
 		return null;
 	}
 
-	public computeLinks(uri: string): ILink[] {
+	public computeLinks(uri: string): Promise<ILink[]> {
 		const model = this.getModel(uri);
 		if (!model) {
 			return void 0;
@@ -81,7 +81,7 @@ export class OutputLinkComputer {
 			}
 		});
 
-		return links;
+		return Promise.resolve(links);
 	}
 
 	public static createPatterns(workspaceFolder: URI): RegExp[] {
diff --git a/src/vs/workbench/parts/output/common/outputLinkProvider.ts b/src/vs/workbench/parts/output/common/outputLinkProvider.ts
index f9fb24af057..de9ae22b121 100644
--- a/src/vs/workbench/parts/output/common/outputLinkProvider.ts
+++ b/src/vs/workbench/parts/output/common/outputLinkProvider.ts
@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { TPromise } from 'vs/base/common/winjs.base';
 import { URI } from 'vs/base/common/uri';
 import { RunOnceScheduler } from 'vs/base/common/async';
 import { IModelService } from 'vs/editor/common/services/modelService';
@@ -75,7 +74,7 @@ export class OutputLinkProvider {
 		return this.worker;
 	}
 
-	private provideLinks(modelUri: URI): TPromise<ILink[]> {
+	private provideLinks(modelUri: URI): Promise<ILink[]> {
 		return this.getOrCreateWorker().withSyncedResources([modelUri]).then(linkComputer => {
 			return linkComputer.computeLinks(modelUri.toString());
 		});

From fdf2dec52d1bafd37978e8cdf24371af7f49f8e7 Mon Sep 17 00:00:00 2001
From: Alex Dima <alexdima@microsoft.com>
Date: Tue, 9 Oct 2018 09:46:54 +0200
Subject: [PATCH 38/76] Remove usage of TPromise from public editor API
 (#53526)

---
 build/monaco/api.js                                   |  1 -
 build/monaco/api.ts                                   |  1 -
 src/vs/editor/browser/widget/codeEditorWidget.ts      |  4 ++--
 src/vs/editor/common/editorAction.ts                  | 11 +++++------
 src/vs/editor/common/editorCommon.ts                  |  3 +--
 src/vs/editor/standalone/browser/colorizer.ts         |  9 ++++-----
 .../standalone/browser/quickOpen/quickCommand.ts      |  3 +--
 .../editor/standalone/browser/standaloneCodeEditor.ts |  8 +++-----
 src/vs/editor/standalone/browser/standaloneEditor.ts  |  4 ++--
 .../parts/quickopen/browser/commandsHandler.ts        |  2 +-
 10 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/build/monaco/api.js b/build/monaco/api.js
index d4502c97997..f411ab4a566 100644
--- a/build/monaco/api.js
+++ b/build/monaco/api.js
@@ -315,7 +315,6 @@ function generateDeclarationFile(out, inputFiles, recipe) {
     var resultTxt = result.join(endl);
     resultTxt = resultTxt.replace(/\bURI\b/g, 'Uri');
     resultTxt = resultTxt.replace(/\bEvent</g, 'IEvent<');
-    resultTxt = resultTxt.replace(/\bTPromise</g, 'Promise<');
     resultTxt = format(resultTxt);
     return [
         resultTxt,
diff --git a/build/monaco/api.ts b/build/monaco/api.ts
index 3281c876f14..8c9e2b03890 100644
--- a/build/monaco/api.ts
+++ b/build/monaco/api.ts
@@ -366,7 +366,6 @@ function generateDeclarationFile(out: string, inputFiles: { [file: string]: stri
 	let resultTxt = result.join(endl);
 	resultTxt = resultTxt.replace(/\bURI\b/g, 'Uri');
 	resultTxt = resultTxt.replace(/\bEvent</g, 'IEvent<');
-	resultTxt = resultTxt.replace(/\bTPromise</g, 'Promise<');
 
 	resultTxt = format(resultTxt);
 
diff --git a/src/vs/editor/browser/widget/codeEditorWidget.ts b/src/vs/editor/browser/widget/codeEditorWidget.ts
index dc5f8d54f0c..67bc8a7d23c 100644
--- a/src/vs/editor/browser/widget/codeEditorWidget.ts
+++ b/src/vs/editor/browser/widget/codeEditorWidget.ts
@@ -287,9 +287,9 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
 				action.label,
 				action.alias,
 				action.precondition,
-				(): void | TPromise<void> => {
+				(): Promise<void> => {
 					return this._instantiationService.invokeFunction((accessor) => {
-						return action.runEditorCommand(accessor, this, null);
+						return Promise.resolve(action.runEditorCommand(accessor, this, null));
 					});
 				},
 				this._contextKeyService
diff --git a/src/vs/editor/common/editorAction.ts b/src/vs/editor/common/editorAction.ts
index b0f8fcbe71a..ce29a961c5d 100644
--- a/src/vs/editor/common/editorAction.ts
+++ b/src/vs/editor/common/editorAction.ts
@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IEditorAction } from 'vs/editor/common/editorCommon';
 import { IContextKeyService, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 
@@ -14,7 +13,7 @@ export class InternalEditorAction implements IEditorAction {
 	public readonly alias: string;
 
 	private readonly _precondition: ContextKeyExpr;
-	private readonly _run: () => void | TPromise<void>;
+	private readonly _run: () => Promise<void>;
 	private readonly _contextKeyService: IContextKeyService;
 
 	constructor(
@@ -22,7 +21,7 @@ export class InternalEditorAction implements IEditorAction {
 		label: string,
 		alias: string,
 		precondition: ContextKeyExpr,
-		run: () => void,
+		run: () => Promise<void>,
 		contextKeyService: IContextKeyService
 	) {
 		this.id = id;
@@ -37,12 +36,12 @@ export class InternalEditorAction implements IEditorAction {
 		return this._contextKeyService.contextMatchesRules(this._precondition);
 	}
 
-	public run(): TPromise<void> {
+	public run(): Promise<void> {
 		if (!this.isSupported()) {
-			return TPromise.as(void 0);
+			return Promise.resolve(void 0);
 		}
 
 		const r = this._run();
-		return r ? r : TPromise.as(void 0);
+		return r ? r : Promise.resolve(void 0);
 	}
 }
diff --git a/src/vs/editor/common/editorCommon.ts b/src/vs/editor/common/editorCommon.ts
index 5f940755d70..78829d1fe2b 100644
--- a/src/vs/editor/common/editorCommon.ts
+++ b/src/vs/editor/common/editorCommon.ts
@@ -5,7 +5,6 @@
 
 import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Position, IPosition } from 'vs/editor/common/core/position';
 import { Range, IRange } from 'vs/editor/common/core/range';
@@ -185,7 +184,7 @@ export interface IEditorAction {
 	readonly label: string;
 	readonly alias: string;
 	isSupported(): boolean;
-	run(): TPromise<void>;
+	run(): Promise<void>;
 }
 
 export type IEditorModel = ITextModel | IDiffEditorModel;
diff --git a/src/vs/editor/standalone/browser/colorizer.ts b/src/vs/editor/standalone/browser/colorizer.ts
index a0c88e7e18f..4e79aaaed50 100644
--- a/src/vs/editor/standalone/browser/colorizer.ts
+++ b/src/vs/editor/standalone/browser/colorizer.ts
@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ITextModel } from 'vs/editor/common/model';
 import { ColorId, MetadataConsts, FontStyle, TokenizationRegistry, ITokenizationSupport } from 'vs/editor/common/modes';
 import { IModeService } from 'vs/editor/common/services/modeService';
@@ -26,7 +25,7 @@ export interface IColorizerElementOptions extends IColorizerOptions {
 
 export class Colorizer {
 
-	public static colorizeElement(themeService: IStandaloneThemeService, modeService: IModeService, domNode: HTMLElement, options: IColorizerElementOptions): TPromise<void> {
+	public static colorizeElement(themeService: IStandaloneThemeService, modeService: IModeService, domNode: HTMLElement, options: IColorizerElementOptions): Promise<void> {
 		options = options || {};
 		let theme = options.theme || 'vs';
 		let mimeType = options.mimeType || domNode.getAttribute('lang') || domNode.getAttribute('data-lang');
@@ -45,7 +44,7 @@ export class Colorizer {
 		return this.colorize(modeService, text, mimeType, options).then(render, (err) => console.error(err));
 	}
 
-	public static colorize(modeService: IModeService, text: string, mimeType: string, options: IColorizerOptions): TPromise<string> {
+	public static colorize(modeService: IModeService, text: string, mimeType: string, options: IColorizerOptions): Promise<string> {
 		if (strings.startsWithUTF8BOM(text)) {
 			text = text.substr(1);
 		}
@@ -62,10 +61,10 @@ export class Colorizer {
 
 		let tokenizationSupport = TokenizationRegistry.get(language);
 		if (tokenizationSupport) {
-			return TPromise.as(_colorize(lines, options.tabSize, tokenizationSupport));
+			return Promise.resolve(_colorize(lines, options.tabSize, tokenizationSupport));
 		}
 
-		return new TPromise<string>((resolve, reject) => {
+		return new Promise<string>((resolve, reject) => {
 			let listener: IDisposable = null;
 			let timeout: TimeoutTimer = null;
 
diff --git a/src/vs/editor/standalone/browser/quickOpen/quickCommand.ts b/src/vs/editor/standalone/browser/quickOpen/quickCommand.ts
index b7928bcbab6..b3b30c1b95b 100644
--- a/src/vs/editor/standalone/browser/quickOpen/quickCommand.ts
+++ b/src/vs/editor/standalone/browser/quickOpen/quickCommand.ts
@@ -6,7 +6,6 @@
 import * as nls from 'vs/nls';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { matchesFuzzy } from 'vs/base/common/filters';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IContext, IHighlight, QuickOpenEntryGroup, QuickOpenModel } from 'vs/base/parts/quickopen/browser/quickOpenModel';
 import { IAutoFocus, Mode } from 'vs/base/parts/quickopen/common/quickOpen';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
@@ -55,7 +54,7 @@ export class EditorActionCommandEntry extends QuickOpenEntryGroup {
 				this.editor.focus();
 
 				try {
-					let promise = this.action.run() || TPromise.as(null);
+					let promise = this.action.run() || Promise.resolve();
 					promise.then(null, onUnexpectedError);
 				} catch (error) {
 					onUnexpectedError(error);
diff --git a/src/vs/editor/standalone/browser/standaloneCodeEditor.ts b/src/vs/editor/standalone/browser/standaloneCodeEditor.ts
index 8e69016587e..0b8eb55f9ab 100644
--- a/src/vs/editor/standalone/browser/standaloneCodeEditor.ts
+++ b/src/vs/editor/standalone/browser/standaloneCodeEditor.ts
@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable, IDisposable, combinedDisposable, toDisposable } from 'vs/base/common/lifecycle';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IContextViewService } from 'vs/platform/contextview/browser/contextView';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { CommandsRegistry, ICommandService, ICommandHandler } from 'vs/platform/commands/common/commands';
@@ -72,7 +71,7 @@ export interface IActionDescriptor {
 	 * Method that will be executed when the action is triggered.
 	 * @param editor The editor instance is passed in as a convinience
 	 */
-	run(editor: ICodeEditor): void | TPromise<void>;
+	run(editor: ICodeEditor): void | Promise<void>;
 }
 
 /**
@@ -221,9 +220,8 @@ export class StandaloneCodeEditor extends CodeEditorWidget implements IStandalon
 		);
 		const contextMenuGroupId = _descriptor.contextMenuGroupId || null;
 		const contextMenuOrder = _descriptor.contextMenuOrder || 0;
-		const run = (): TPromise<void> => {
-			const r = _descriptor.run(this);
-			return r ? r : TPromise.as(void 0);
+		const run = (): Promise<void> => {
+			return Promise.resolve(_descriptor.run(this));
 		};
 
 
diff --git a/src/vs/editor/standalone/browser/standaloneEditor.ts b/src/vs/editor/standalone/browser/standaloneEditor.ts
index 2aa953c0596..a85dd145bea 100644
--- a/src/vs/editor/standalone/browser/standaloneEditor.ts
+++ b/src/vs/editor/standalone/browser/standaloneEditor.ts
@@ -240,14 +240,14 @@ export function createWebWorker<T>(opts: IWebWorkerOptions): MonacoWebWorker<T>
 /**
  * Colorize the contents of `domNode` using attribute `data-lang`.
  */
-export function colorizeElement(domNode: HTMLElement, options: IColorizerElementOptions): TPromise<void> {
+export function colorizeElement(domNode: HTMLElement, options: IColorizerElementOptions): Promise<void> {
 	return Colorizer.colorizeElement(StaticServices.standaloneThemeService.get(), StaticServices.modeService.get(), domNode, options);
 }
 
 /**
  * Colorize `text` using language `languageId`.
  */
-export function colorize(text: string, languageId: string, options: IColorizerOptions): TPromise<string> {
+export function colorize(text: string, languageId: string, options: IColorizerOptions): Promise<string> {
 	return Colorizer.colorize(StaticServices.modeService.get(), text, languageId, options);
 }
 
diff --git a/src/vs/workbench/parts/quickopen/browser/commandsHandler.ts b/src/vs/workbench/parts/quickopen/browser/commandsHandler.ts
index 1c5bff83890..a1c28485cde 100644
--- a/src/vs/workbench/parts/quickopen/browser/commandsHandler.ts
+++ b/src/vs/workbench/parts/quickopen/browser/commandsHandler.ts
@@ -304,7 +304,7 @@ abstract class BaseCommandEntry extends QuickOpenEntryGroup {
 						}
 					*/
 					this.telemetryService.publicLog('workbenchActionExecuted', { id: action.id, from: 'quick open' });
-					(action.run() || TPromise.as(null)).then(() => {
+					(action.run() || Promise.resolve()).then(() => {
 						if (action instanceof Action) {
 							action.dispose();
 						}

From fd655a5462265e4216cd9b3d1b6482d1fb33cb3c Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:20:21 +0200
Subject: [PATCH 39/76] fix breadcrumbs keybinding select issue

---
 src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts b/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
index 515593ff365..cfe0453ff28 100644
--- a/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
+++ b/src/vs/workbench/browser/parts/editor/breadcrumbsControl.ts
@@ -323,7 +323,7 @@ export class BreadcrumbsControl {
 						editorViewState = undefined;
 					}
 					this._contextViewService.hideContextView(this);
-					this._revealInEditor(event, data.target, this._getEditorGroup(data.payload && data.payload.originalEvent), (data.payload && data.payload.originalEvent.middleButton));
+					this._revealInEditor(event, data.target, this._getEditorGroup(data.payload && data.payload.originalEvent), (data.payload && data.payload.originalEvent && data.payload.originalEvent.middleButton));
 					/* __GDPR__
 						"breadcrumbs/open" : {
 							"type": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

From 0741911a0f8faf0c0842a17f05f8c6f18f6c5178 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:28:25 +0200
Subject: [PATCH 40/76] add test for #60232

---
 .../editor/test/common/modes/languageSelector.test.ts  | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/vs/editor/test/common/modes/languageSelector.test.ts b/src/vs/editor/test/common/modes/languageSelector.test.ts
index f56c0368c59..8d43170b22c 100644
--- a/src/vs/editor/test/common/modes/languageSelector.test.ts
+++ b/src/vs/editor/test/common/modes/languageSelector.test.ts
@@ -94,4 +94,14 @@ suite('LanguageSelector', function () {
 		assert.equal(score({ language: 'javascript', scheme: 'file', hasAccessToAllModels: true }, doc.uri, doc.langId, false), 10);
 		assert.equal(score(['fooLang', '*', { language: '*', hasAccessToAllModels: true }], doc.uri, doc.langId, false), 5);
 	});
+
+	test('Document selector match - unexpected result value #60232', function () {
+		let selector = {
+			language: 'json',
+			scheme: 'file',
+			pattern: '**/*.interface.json'
+		};
+		let value = score(selector, URI.parse('file:///C:/Users/zlhe/Desktop/test.interface.json'), 'json', true);
+		assert.equal(value, 10);
+	});
 });

From 711217acc508e70269e4940c1c12403e7578d96d Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:33:26 +0200
Subject: [PATCH 41/76] debt - less TPromise usage

---
 src/vs/editor/standalone/browser/quickOpen/quickOutline.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/vs/editor/standalone/browser/quickOpen/quickOutline.ts b/src/vs/editor/standalone/browser/quickOpen/quickOutline.ts
index c3babe9b43a..f81c9c3801b 100644
--- a/src/vs/editor/standalone/browser/quickOpen/quickOutline.ts
+++ b/src/vs/editor/standalone/browser/quickOpen/quickOutline.ts
@@ -7,7 +7,6 @@ import 'vs/css!./quickOutline';
 import * as nls from 'vs/nls';
 import { matchesFuzzy } from 'vs/base/common/filters';
 import * as strings from 'vs/base/common/strings';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IContext, IHighlight, QuickOpenEntryGroup, QuickOpenModel } from 'vs/base/parts/quickopen/browser/quickOpenModel';
 import { IAutoFocus, Mode } from 'vs/base/parts/quickopen/common/quickOpen';
 import { ScrollType } from 'vs/editor/common/editorCommon';
@@ -129,7 +128,7 @@ export class QuickOutlineAction extends BaseEditorQuickOpenAction {
 		});
 	}
 
-	public run(accessor: ServicesAccessor, editor: ICodeEditor): TPromise<void> {
+	public run(accessor: ServicesAccessor, editor: ICodeEditor): Thenable<void> {
 
 		let model = editor.getModel();
 
@@ -138,13 +137,13 @@ export class QuickOutlineAction extends BaseEditorQuickOpenAction {
 		}
 
 		// Resolve outline
-		return TPromise.wrap(getDocumentSymbols(model, true, CancellationToken.None).then((result: DocumentSymbol[]) => {
+		return getDocumentSymbols(model, true, CancellationToken.None).then((result: DocumentSymbol[]) => {
 			if (result.length === 0) {
 				return;
 			}
 
 			this._run(editor, result);
-		}));
+		});
 	}
 
 	private _run(editor: ICodeEditor, result: DocumentSymbol[]): void {

From 291f9af1748f5be412f0491b0fcbe9c1b80ac17a Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:35:13 +0200
Subject: [PATCH 42/76] debt - less TPromise usage

---
 src/vs/workbench/api/node/extHostWorkspace.ts | 21 ++++++++-----------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/vs/workbench/api/node/extHostWorkspace.ts b/src/vs/workbench/api/node/extHostWorkspace.ts
index 215deb22d3a..08a022a9fad 100644
--- a/src/vs/workbench/api/node/extHostWorkspace.ts
+++ b/src/vs/workbench/api/node/extHostWorkspace.ts
@@ -13,7 +13,6 @@ import { isLinux } from 'vs/base/common/platform';
 import { basenameOrAuthority, dirname, isEqual } from 'vs/base/common/resources';
 import { compare } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { localize } from 'vs/nls';
 import { ILogService } from 'vs/platform/log/common/log';
 import { Severity } from 'vs/platform/notification/common/notification';
@@ -373,7 +372,7 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {
 		}
 
 		if (token && token.isCancellationRequested) {
-			return TPromise.wrap([]);
+			return Promise.resolve([]);
 		}
 
 		return this._proxy.$startFileSearch(includePattern, includeFolder, excludePatternOrDisregardExcludes, maxResults, token)
@@ -433,18 +432,16 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {
 		};
 
 		if (token.isCancellationRequested) {
-			return TPromise.wrap(undefined);
+			return Promise.resolve(undefined);
 		}
 
-		return this._proxy.$startTextSearch(query, queryOptions, requestId, token).then(
-			result => {
-				delete this._activeSearchCallbacks[requestId];
-				return result;
-			},
-			err => {
-				delete this._activeSearchCallbacks[requestId];
-				return TPromise.wrapError(err);
-			});
+		return this._proxy.$startTextSearch(query, queryOptions, requestId, token).then(result => {
+			delete this._activeSearchCallbacks[requestId];
+			return result;
+		}, err => {
+			delete this._activeSearchCallbacks[requestId];
+			return Promise.reject(err);
+		});
 	}
 
 	$handleTextSearchResult(result: IRawFileMatch2, requestId: number): void {

From 6ea40d7b9e64cf0bdd69d2a0d0425b864d9d28b0 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:40:34 +0200
Subject: [PATCH 43/76] debt - less TPromise usage

---
 .../electron-browser/remoteFileService.ts     | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/vs/workbench/services/files/electron-browser/remoteFileService.ts b/src/vs/workbench/services/files/electron-browser/remoteFileService.ts
index ffd8d26bcc0..f08e96ed830 100644
--- a/src/vs/workbench/services/files/electron-browser/remoteFileService.ts
+++ b/src/vs/workbench/services/files/electron-browser/remoteFileService.ts
@@ -55,7 +55,7 @@ function toIFileStat(provider: IFileSystemProvider, tuple: [URI, IStat], recurse
 			// dir -> resolve
 			return provider.readdir(resource).then(entries => {
 				// resolve children if requested
-				return TPromise.join(entries.map(tuple => {
+				return Promise.all(entries.map(tuple => {
 					const [name, type] = tuple;
 					const childResource = resources.joinPath(resource, name);
 					return toIFileStat(provider, [childResource, new TypeOnlyStat(type)], recurse);
@@ -68,7 +68,7 @@ function toIFileStat(provider: IFileSystemProvider, tuple: [URI, IStat], recurse
 	}
 
 	// file or (un-resolved) dir
-	return TPromise.as(fileStat);
+	return Promise.resolve(fileStat);
 }
 
 export function toDeepIFileStat(provider: IFileSystemProvider, tuple: [URI, IStat], to: URI[]): Thenable<IFileStat> {
@@ -243,7 +243,7 @@ export class RemoteFileService extends FileService {
 
 	// --- stat
 
-	private _withProvider(resource: URI): TPromise<IFileSystemProvider> {
+	private _withProvider(resource: URI): Promise<IFileSystemProvider> {
 
 		if (!resources.isAbsolutePath(resource)) {
 			throw new FileOperationError(
@@ -252,7 +252,7 @@ export class RemoteFileService extends FileService {
 			);
 		}
 
-		return TPromise.join([
+		return Promise.all([
 			this._extensionService.activateByEvent('onFileSystem:' + resource.scheme)
 		]).then(() => {
 			const provider = this._provider.get(resource.scheme);
@@ -270,7 +270,7 @@ export class RemoteFileService extends FileService {
 		if (resource.scheme === Schemas.file) {
 			return super.existsFile(resource);
 		} else {
-			return this.resolveFile(resource).then(data => true, err => false);
+			return this.resolveFile(resource).then(_data => true, _err => false);
 		}
 	}
 
@@ -315,7 +315,7 @@ export class RemoteFileService extends FileService {
 		return TPromise.join(promises).then(data => flatten(data));
 	}
 
-	private _doResolveFiles(toResolve: { resource: URI; options?: IResolveFileOptions; }[]): TPromise<IResolveFileResult[]> {
+	private _doResolveFiles(toResolve: { resource: URI; options?: IResolveFileOptions; }[]): Promise<IResolveFileResult[]> {
 		return this._withProvider(toResolve[0].resource).then(provider => {
 			let result: IResolveFileResult[] = [];
 			let promises = toResolve.map((item, idx) => {
@@ -327,7 +327,7 @@ export class RemoteFileService extends FileService {
 					result[idx] = { stat: undefined, success: false };
 				});
 			});
-			return TPromise.join(promises).then(() => result);
+			return Promise.all(promises).then(() => result);
 		});
 	}
 
@@ -349,7 +349,7 @@ export class RemoteFileService extends FileService {
 		}
 	}
 
-	private _readFile(resource: URI, options: IResolveContentOptions = Object.create(null)): TPromise<IStreamContent> {
+	private _readFile(resource: URI, options: IResolveContentOptions = Object.create(null)): Promise<IStreamContent> {
 		return this._withProvider(resource).then(provider => {
 
 			return this.resolveFile(resource).then(fileStat => {
@@ -383,7 +383,7 @@ export class RemoteFileService extends FileService {
 				return toDecodeStream(readable, decodeStreamOpts).then(data => {
 
 					if (options.acceptTextOnly && data.detected.seemsBinary) {
-						return TPromise.wrapError<IStreamContent>(new FileOperationError(
+						return Promise.reject(new FileOperationError(
 							localize('fileBinaryError', "File seems to be binary and cannot be opened as text"),
 							FileOperationResult.FILE_IS_BINARY,
 							options
@@ -543,11 +543,11 @@ export class RemoteFileService extends FileService {
 		}
 	}
 
-	private _doMoveWithInScheme(source: URI, target: URI, overwrite?: boolean): TPromise<IFileStat> {
+	private _doMoveWithInScheme(source: URI, target: URI, overwrite?: boolean): Promise<IFileStat> {
 
 		const prepare = overwrite
-			? this.del(target, { recursive: true }).then(undefined, err => { /*ignore*/ })
-			: TPromise.as(null);
+			? Promise.resolve(this.del(target, { recursive: true }).then(undefined, err => { /*ignore*/ }))
+			: Promise.resolve(null);
 
 		return prepare.then(() => this._withProvider(source)).then(RemoteFileService._throwIfFileSystemIsReadonly).then(provider => {
 			return provider.rename(source, target, { overwrite }).then(() => {
@@ -600,8 +600,8 @@ export class RemoteFileService extends FileService {
 			}
 
 			const prepare = overwrite
-				? this.del(target, { recursive: true }).then(undefined, err => { /*ignore*/ })
-				: TPromise.as(null);
+				? Promise.resolve(this.del(target, { recursive: true }).then(undefined, err => { /*ignore*/ }))
+				: Promise.resolve(null);
 
 			return prepare.then(() => {
 				// todo@ben, can only copy text files
@@ -625,7 +625,7 @@ export class RemoteFileService extends FileService {
 							// file scheme
 							return super.updateContent(target, content.value, { encoding: content.encoding });
 						} else {
-							return TPromise.wrapError(err);
+							return Promise.reject(err);
 						}
 					});
 				});

From 5300bc54b49a24668526d3053e17c66ef26ec236 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 10:43:43 +0200
Subject: [PATCH 44/76] debt - less TPromise usage

---
 src/vs/workbench/api/electron-browser/mainThreadCommands.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/vs/workbench/api/electron-browser/mainThreadCommands.ts b/src/vs/workbench/api/electron-browser/mainThreadCommands.ts
index 41109430a65..4753577d61c 100644
--- a/src/vs/workbench/api/electron-browser/mainThreadCommands.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadCommands.ts
@@ -5,7 +5,6 @@
 
 import { ICommandService, CommandsRegistry, ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ExtHostContext, MainThreadCommandsShape, ExtHostCommandsShape, MainContext, IExtHostContext } from '../node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { revive } from 'vs/base/common/marshalling';
@@ -79,7 +78,7 @@ export class MainThreadCommands implements MainThreadCommandsShape {
 	}
 
 	$getCommands(): Thenable<string[]> {
-		return TPromise.as(Object.keys(CommandsRegistry.getCommands()));
+		return Promise.resolve(Object.keys(CommandsRegistry.getCommands()));
 	}
 }
 

From 5bd6ebe2dbc4dee510699020a25f70a69784ce8c Mon Sep 17 00:00:00 2001
From: Joao Moreno <joao.moreno@microsoft.com>
Date: Tue, 9 Oct 2018 10:57:39 +0200
Subject: [PATCH 45/76] move Promise back to TPromise in nfcall

related to #60163
---
 src/vs/base/common/async.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/base/common/async.ts b/src/vs/base/common/async.ts
index cc3d388ce35..bcf32e22066 100644
--- a/src/vs/base/common/async.ts
+++ b/src/vs/base/common/async.ts
@@ -657,7 +657,7 @@ export class RunOnceWorker<T> extends RunOnceScheduler {
 export function nfcall(fn: Function, ...args: any[]): Promise<any>;
 export function nfcall<T>(fn: Function, ...args: any[]): Promise<T>;
 export function nfcall(fn: Function, ...args: any[]): any {
-	return new Promise((c, e) => fn(...args, (err: any, result: any) => err ? e(err) : c(result)));
+	return new TPromise((c, e) => fn(...args, (err: any, result: any) => err ? e(err) : c(result)));
 }
 
 export function ninvoke(thisArg: any, fn: Function, ...args: any[]): TPromise;

From 099c23febca61c3ac99066e472fc1e08ed88b24a Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 12:07:13 +0200
Subject: [PATCH 46/76] repl: allow to inspect repl output of inactive sessions

---
 .../mainThreadDebugService.ts                 |   2 +-
 .../parts/debug/browser/debugActionItems.ts   |  12 +-
 .../parts/debug/browser/debugActions.ts       |  25 ---
 src/vs/workbench/parts/debug/common/debug.ts  |   7 +-
 .../parts/debug/common/debugModel.ts          |  14 +-
 .../electron-browser/debug.contribution.ts    |   3 +-
 .../debug/electron-browser/debugService.ts    |  12 +-
 .../debug/electron-browser/debugSession.ts    |  11 +-
 .../parts/debug/electron-browser/repl.ts      | 183 ++++++++++++------
 .../debug/electron-browser/replViewer.ts      |   8 +-
 .../parts/debug/test/common/mockDebug.ts      |   4 -
 .../test/electron-browser/debugModel.test.ts  |   6 +-
 12 files changed, 155 insertions(+), 132 deletions(-)

diff --git a/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts b/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
index e470a4f367a..f41a7b9caf0 100644
--- a/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadDebugService.ts
@@ -190,7 +190,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 	}
 
 	public $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Thenable<any> {
-		const session = this.debugService.getSession(sessionId);
+		const session = this.debugService.getModel().getSessions(true).filter(s => s.getId() === sessionId).pop();
 		if (session) {
 			return session.customRequest(request, args).then(response => {
 				if (response && response.success) {
diff --git a/src/vs/workbench/parts/debug/browser/debugActionItems.ts b/src/vs/workbench/parts/debug/browser/debugActionItems.ts
index cc8559fe8d9..52fc337a4ae 100644
--- a/src/vs/workbench/parts/debug/browser/debugActionItems.ts
+++ b/src/vs/workbench/parts/debug/browser/debugActionItems.ts
@@ -12,7 +12,7 @@ import { SelectBox } from 'vs/base/browser/ui/selectBox/selectBox';
 import { SelectActionItem, IActionItem } from 'vs/base/browser/ui/actionbar/actionbar';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import { IDebugService } from 'vs/workbench/parts/debug/common/debug';
+import { IDebugService, IDebugSession } from 'vs/workbench/parts/debug/common/debug';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
 import { attachSelectBoxStyler, attachStylerCallback } from 'vs/platform/theme/common/styler';
 import { SIDE_BAR_BACKGROUND } from 'vs/workbench/common/theme';
@@ -190,7 +190,7 @@ export class StartDebugActionItem implements IActionItem {
 export class FocusSessionActionItem extends SelectActionItem {
 	constructor(
 		action: IAction,
-		@IDebugService private debugService: IDebugService,
+		@IDebugService protected debugService: IDebugService,
 		@IThemeService themeService: IThemeService,
 		@IContextViewService contextViewService: IContextViewService,
 	) {
@@ -201,7 +201,7 @@ export class FocusSessionActionItem extends SelectActionItem {
 		this.toDispose.push(this.debugService.getViewModel().onDidFocusSession(() => {
 			const session = this.debugService.getViewModel().focusedSession;
 			if (session) {
-				const index = this.debugService.getModel().getSessions().indexOf(session);
+				const index = this.getSessions().indexOf(session);
 				this.select(index);
 			}
 		}));
@@ -214,8 +214,12 @@ export class FocusSessionActionItem extends SelectActionItem {
 
 	private update() {
 		const session = this.debugService.getViewModel().focusedSession;
-		const sessions = this.debugService.getModel().getSessions();
+		const sessions = this.getSessions();
 		const names = sessions.map(s => s.getLabel());
 		this.setOptions(names, session ? sessions.indexOf(session) : undefined);
 	}
+
+	protected getSessions(): ReadonlyArray<IDebugSession> {
+		return this.debugService.getModel().getSessions();
+	}
 }
diff --git a/src/vs/workbench/parts/debug/browser/debugActions.ts b/src/vs/workbench/parts/debug/browser/debugActions.ts
index b7818064d6f..31df8070f8a 100644
--- a/src/vs/workbench/parts/debug/browser/debugActions.ts
+++ b/src/vs/workbench/parts/debug/browser/debugActions.ts
@@ -9,7 +9,6 @@ import * as lifecycle from 'vs/base/common/lifecycle';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import * as aria from 'vs/base/browser/ui/aria/aria';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IFileService } from 'vs/platform/files/common/files';
 import { IDebugService, State, IDebugSession, IThread, IEnablement, IBreakpoint, IStackFrame, REPL_ID }
@@ -677,30 +676,6 @@ export class RemoveAllWatchExpressionsAction extends AbstractDebugAction {
 	}
 }
 
-export class ClearReplAction extends AbstractDebugAction {
-	static readonly ID = 'workbench.debug.panel.action.clearReplAction';
-	static LABEL = nls.localize('clearRepl', "Clear Console");
-
-	constructor(id: string, label: string,
-		@IDebugService debugService: IDebugService,
-		@IKeybindingService keybindingService: IKeybindingService,
-		@IPanelService private panelService: IPanelService
-	) {
-		super(id, label, 'debug-action clear-repl', debugService, keybindingService);
-	}
-
-	public run(): TPromise<any> {
-		const session = this.debugService.getViewModel().focusedSession;
-		if (session) {
-			session.removeReplExpressions();
-			aria.status(nls.localize('debugConsoleCleared', "Debug console was cleared"));
-		}
-
-		// focus back to repl
-		return this.panelService.openPanel(REPL_ID, true);
-	}
-}
-
 export class ToggleReplAction extends TogglePanelAction {
 	static readonly ID = 'workbench.debug.action.toggleRepl';
 	static LABEL = nls.localize({ comment: ['Debug is a noun in this context, not a verb.'], key: 'debugConsoleAction' }, 'Debug Console');
diff --git a/src/vs/workbench/parts/debug/common/debug.ts b/src/vs/workbench/parts/debug/common/debug.ts
index d8af85b2cec..addce369d6c 100644
--- a/src/vs/workbench/parts/debug/common/debug.ts
+++ b/src/vs/workbench/parts/debug/common/debug.ts
@@ -376,7 +376,7 @@ export interface IViewModel extends ITreeElement {
 }
 
 export interface IDebugModel extends ITreeElement {
-	getSessions(): ReadonlyArray<IDebugSession>;
+	getSessions(includeInactive?: boolean): ReadonlyArray<IDebugSession>;
 	getBreakpoints(filter?: { uri?: uri, lineNumber?: number, column?: number, enabledOnly?: boolean }): ReadonlyArray<IBreakpoint>;
 	areBreakpointsActivated(): boolean;
 	getFunctionBreakpoints(): ReadonlyArray<IFunctionBreakpoint>;
@@ -772,11 +772,6 @@ export interface IDebugService {
 	 */
 	sourceIsNotAvailable(uri: uri): void;
 
-	/**
-	 * returns Session with the given ID (or undefined if ID is not found)
-	 */
-	getSession(sessionId: string): IDebugSession;
-
 	/**
 	 * Gets the current debug model.
 	 */
diff --git a/src/vs/workbench/parts/debug/common/debugModel.ts b/src/vs/workbench/parts/debug/common/debugModel.ts
index a5f38180727..a27da68f7aa 100644
--- a/src/vs/workbench/parts/debug/common/debugModel.ts
+++ b/src/vs/workbench/parts/debug/common/debugModel.ts
@@ -17,7 +17,7 @@ import { distinct } from 'vs/base/common/arrays';
 import { Range, IRange } from 'vs/editor/common/core/range';
 import {
 	ITreeElement, IExpression, IExpressionContainer, IDebugSession, IStackFrame, IExceptionBreakpoint, IBreakpoint, IFunctionBreakpoint, IDebugModel, IReplElementSource,
-	IThread, IRawModelUpdate, IScope, IRawStoppedDetails, IEnablement, IBreakpointData, IExceptionInfo, IReplElement, IBreakpointsChangeEvent, IBreakpointUpdateData, IBaseBreakpoint
+	IThread, IRawModelUpdate, IScope, IRawStoppedDetails, IEnablement, IBreakpointData, IExceptionInfo, IReplElement, IBreakpointsChangeEvent, IBreakpointUpdateData, IBaseBreakpoint, State
 } from 'vs/workbench/parts/debug/common/debug';
 import { Source } from 'vs/workbench/parts/debug/common/debugSource';
 import { commonSuffixLength } from 'vs/base/common/strings';
@@ -751,16 +751,16 @@ export class DebugModel implements IDebugModel {
 		return 'root';
 	}
 
-	public getSessions(): IDebugSession[] {
-		return this.sessions;
+	public getSessions(includeInactive = false): IDebugSession[] {
+		// By default do not return inactive sesions.
+		// However we are still holding onto inactive sessions due to repl and debug service session revival (eh scenario)
+		return this.sessions.filter(s => includeInactive || s.state !== State.Inactive);
 	}
 
 	public addSession(session: IDebugSession): void {
+		// Make sure to remove all inactive sessions once a new session is started
+		this.sessions = this.sessions.filter(s => s.state !== State.Inactive);
 		this.sessions.push(session);
-	}
-
-	public removeSession(id: string): void {
-		this.sessions = this.sessions.filter(p => p.getId() !== id);
 		this._onDidChangeCallStack.fire();
 	}
 
diff --git a/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts b/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
index db53d6ad76b..4f3652fdb42 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
@@ -30,7 +30,7 @@ import { IPartService } from 'vs/workbench/services/part/common/partService';
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { DebugEditorModelManager } from 'vs/workbench/parts/debug/browser/debugEditorModelManager';
 import {
-	StepOverAction, ClearReplAction, FocusReplAction, StepIntoAction, StepOutAction, StartAction, RestartAction, ContinueAction, StopAction, DisconnectAction, PauseAction, AddFunctionBreakpointAction,
+	StepOverAction, FocusReplAction, StepIntoAction, StepOutAction, StartAction, RestartAction, ContinueAction, StopAction, DisconnectAction, PauseAction, AddFunctionBreakpointAction,
 	ConfigureAction, DisableAllBreakpointsAction, EnableAllBreakpointsAction, RemoveAllBreakpointsAction, RunAction, ReapplyBreakpointsAction, SelectAndStartAction, TerminateThreadAction
 } from 'vs/workbench/parts/debug/browser/debugActions';
 import { DebugToolbar } from 'vs/workbench/parts/debug/browser/debugToolbar';
@@ -147,7 +147,6 @@ registry.registerWorkbenchAction(new SyncActionDescriptor(RunAction, RunAction.I
 registry.registerWorkbenchAction(new SyncActionDescriptor(RemoveAllBreakpointsAction, RemoveAllBreakpointsAction.ID, RemoveAllBreakpointsAction.LABEL), 'Debug: Remove All Breakpoints', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(EnableAllBreakpointsAction, EnableAllBreakpointsAction.ID, EnableAllBreakpointsAction.LABEL), 'Debug: Enable All Breakpoints', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(DisableAllBreakpointsAction, DisableAllBreakpointsAction.ID, DisableAllBreakpointsAction.LABEL), 'Debug: Disable All Breakpoints', debugCategory);
-registry.registerWorkbenchAction(new SyncActionDescriptor(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL), 'Debug: Clear Console', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(FocusReplAction, FocusReplAction.ID, FocusReplAction.LABEL), 'Debug: Focus on Debug Console View', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(SelectAndStartAction, SelectAndStartAction.ID, SelectAndStartAction.LABEL), 'Debug: Select and Start Debugging', debugCategory);
 
diff --git a/src/vs/workbench/parts/debug/electron-browser/debugService.ts b/src/vs/workbench/parts/debug/electron-browser/debugService.ts
index 4e0ef43dc33..3f3a6f89294 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debugService.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debugService.ts
@@ -81,7 +81,6 @@ export class DebugService implements IDebugService {
 	private model: DebugModel;
 	private viewModel: ViewModel;
 	private configurationManager: ConfigurationManager;
-	private allSessions = new Map<string, IDebugSession>();
 	private toDispose: IDisposable[];
 	private debugType: IContextKey<string>;
 	private debugState: IContextKey<string>;
@@ -138,7 +137,7 @@ export class DebugService implements IDebugService {
 		this.lifecycleService.onShutdown(this.dispose, this);
 
 		this.toDispose.push(this.broadcastService.onBroadcast(broadcast => {
-			const session = this.getSession(broadcast.payload.debugId);
+			const session = this.model.getSessions(true).filter(s => s.getId() === broadcast.payload.debugId).pop();
 			if (session) {
 				switch (broadcast.channel) {
 
@@ -179,10 +178,6 @@ export class DebugService implements IDebugService {
 		}));
 	}
 
-	getSession(sessionId: string): IDebugSession {
-		return this.allSessions.get(sessionId);
-	}
-
 	getModel(): IDebugModel {
 		return this.model;
 	}
@@ -271,10 +266,6 @@ export class DebugService implements IDebugService {
 			this.textFileService.saveAll().then(() => this.configurationService.reloadConfiguration(launch ? launch.workspace : undefined).then(() =>
 				this.extensionService.whenInstalledExtensionsRegistered().then(() => {
 
-					if (this.model.getSessions().length === 0) {
-						this.allSessions.clear();
-					}
-
 					let config: IConfig, compound: ICompound;
 					if (!configOrName) {
 						configOrName = this.configurationManager.selectedConfiguration.name;
@@ -431,7 +422,6 @@ export class DebugService implements IDebugService {
 	private doCreateSession(root: IWorkspaceFolder, configuration: { resolved: IConfig, unresolved: IConfig }): TPromise<boolean> {
 
 		const session = this.instantiationService.createInstance(DebugSession, configuration, root, this.model);
-		this.allSessions.set(session.getId(), session);
 
 		// register listeners as the very first thing!
 		this.registerSessionListeners(session);
diff --git a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
index f8f87ed14b3..bb9731a3d7c 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
@@ -90,6 +90,10 @@ export class DebugSession implements IDebugSession {
 	}
 
 	get state(): State {
+		if (!this.raw) {
+			return State.Inactive;
+		}
+
 		const focusedThread = this.debugService.getViewModel().focusedThread;
 		if (focusedThread && focusedThread.session === this) {
 			return focusedThread.stopped ? State.Stopped : State.Running;
@@ -98,7 +102,7 @@ export class DebugSession implements IDebugSession {
 			return State.Stopped;
 		}
 
-		return !!this.raw ? State.Running : State.Inactive;
+		return State.Running;
 	}
 
 	get capabilities(): DebugProtocol.Capabilities {
@@ -747,14 +751,13 @@ export class DebugSession implements IDebugSession {
 
 	shutdown(): void {
 		dispose(this.rawListeners);
-		this.model.clearThreads(this.getId(), true);
-		this.model.removeSession(this.getId());
-		this._onDidChangeState.fire();
 		this.fetchThreadsScheduler = undefined;
 		if (this.raw) {
 			this.raw.disconnect();
 		}
 		this.raw = undefined;
+		this.model.clearThreads(this.getId(), true);
+		this._onDidChangeState.fire();
 	}
 
 	//---- sources
diff --git a/src/vs/workbench/parts/debug/electron-browser/repl.ts b/src/vs/workbench/parts/debug/electron-browser/repl.ts
index 0a0d7127d64..c9ebbd28319 100644
--- a/src/vs/workbench/parts/debug/electron-browser/repl.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/repl.ts
@@ -8,7 +8,7 @@ import * as nls from 'vs/nls';
 import { URI as uri } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import * as errors from 'vs/base/common/errors';
-import { IAction, IActionItem } from 'vs/base/common/actions';
+import { IAction, IActionItem, Action } from 'vs/base/common/actions';
 import * as dom from 'vs/base/browser/dom';
 import * as aria from 'vs/base/browser/ui/aria/aria';
 import { isMacintosh } from 'vs/base/common/platform';
@@ -29,7 +29,6 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IInstantiationService, createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { ReplExpressionsRenderer, ReplExpressionsController, ReplExpressionsDataSource, ReplExpressionsActionProvider, ReplExpressionsAccessibilityProvider } from 'vs/workbench/parts/debug/electron-browser/replViewer';
-import { ClearReplAction, FocusSessionAction } from 'vs/workbench/parts/debug/browser/debugActions';
 import { Panel } from 'vs/workbench/browser/panel';
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
@@ -41,7 +40,7 @@ import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { OpenMode, ClickBehavior } from 'vs/base/parts/tree/browser/treeDefaults';
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { CodeEditorWidget } from 'vs/editor/browser/widget/codeEditorWidget';
-import { IDebugService, REPL_ID, DEBUG_SCHEME, CONTEXT_IN_DEBUG_REPL } from 'vs/workbench/parts/debug/common/debug';
+import { IDebugService, REPL_ID, DEBUG_SCHEME, CONTEXT_IN_DEBUG_REPL, IDebugSession, State } from 'vs/workbench/parts/debug/common/debug';
 import { HistoryNavigator } from 'vs/base/common/history';
 import { IHistoryNavigationWidget } from 'vs/base/browser/history';
 import { createAndBindHistoryNavigationWidgetScopedContextKeyService } from 'vs/platform/widget/browser/contextScopedHistoryWidget';
@@ -68,10 +67,12 @@ export interface IPrivateReplService {
 	_serviceBrand: any;
 	acceptReplInput(): void;
 	getVisibleContent(): string;
+	selectSession(session: IDebugSession): void;
+	clearRepl(): void;
 }
 
 export class Repl extends Panel implements IPrivateReplService, IHistoryNavigationWidget {
-	public _serviceBrand: any;
+	_serviceBrand: any;
 
 	private static readonly HALF_WIDTH_TYPICAL = 'n';
 
@@ -91,6 +92,8 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 	private replInputHeight: number;
 	private model: ITextModel;
 	private historyNavigationEnablement: IContextKey<boolean>;
+	private scopedInstantiationService: IInstantiationService;
+	private replElementsChangeListener: IDisposable;
 
 	constructor(
 		@IDebugService private debugService: IDebugService,
@@ -112,33 +115,11 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 	}
 
 	private registerListeners(): void {
-		let replElementsChangeListener: IDisposable;
 		this._register(this.debugService.getViewModel().onDidFocusSession(session => {
-			if (replElementsChangeListener) {
-				replElementsChangeListener.dispose();
-			}
-			if (session) {
-				replElementsChangeListener = session.onDidChangeReplElements(() => {
-					this.refreshReplElements(session.getReplElements().length === 0);
-				});
-
-				if (this.tree && this.isVisible()) {
-					this.tree.setInput(session);
-				}
-			}
-			this.replInput.updateOptions({ readOnly: !session });
-			if (this.isVisible()) {
-				this.updateInputDecoration();
-			}
+			this.selectSession(session);
 		}));
-		this._register(this.panelService.onDidPanelOpen(panel => this.refreshReplElements(true)));
+		this._register(this.panelService.onDidPanelOpen(() => this.refreshReplElements(true)));
 		this._register(this.debugService.onDidNewSession(() => this.updateTitleArea()));
-		this._register(this.debugService.onDidEndSession(() => {
-			if (this.debugService.getModel().getSessions().length === 0) {
-				// Only hide the session drop down when there are 0 sessions
-				this.updateTitleArea();
-			}
-		}));
 		this._register(this.themeService.onThemeChange(() => {
 			if (this.isVisible()) {
 				this.updateInputDecoration();
@@ -166,14 +147,14 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 	}
 
-	public async create(parent: HTMLElement): Promise<void> {
+	async create(parent: HTMLElement): Promise<void> {
 		await super.create(parent);
 		this.container = dom.append(parent, $('.repl'));
 		this.treeContainer = dom.append(this.container, $('.repl-tree'));
 		this.createReplInput(this.container);
 
 		this.renderer = this.instantiationService.createInstance(ReplExpressionsRenderer);
-		const controller = this.instantiationService.createInstance(ReplExpressionsController, new ReplExpressionsActionProvider(this.instantiationService, this.replInput), MenuId.DebugConsoleContext, { openMode: OpenMode.SINGLE_CLICK, clickBehavior: ClickBehavior.ON_MOUSE_UP /* do not change, to preserve focus behaviour in input field */ });
+		const controller = this.instantiationService.createInstance(ReplExpressionsController, new ReplExpressionsActionProvider(this.clearReplAction, this.replInput), MenuId.DebugConsoleContext, { openMode: OpenMode.SINGLE_CLICK, clickBehavior: ClickBehavior.ON_MOUSE_UP /* do not change, to preserve focus behaviour in input field */ });
 		controller.toFocusOnClick = this.replInput;
 
 		this.tree = this.instantiationService.createInstance(WorkbenchTree, this.treeContainer, {
@@ -184,7 +165,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}, replTreeOptions);
 	}
 
-	public setVisible(visible: boolean): Promise<void> {
+	setVisible(visible: boolean): Promise<void> {
 		if (!visible) {
 			dispose(this.model);
 		} else {
@@ -193,7 +174,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 			this.updateInputDecoration();
 			const focusedSession = this.debugService.getViewModel().focusedSession;
 			if (focusedSession && this.tree.getInput() !== focusedSession) {
-				this.tree.setInput(focusedSession);
+				this.selectSession(focusedSession);
 			}
 		}
 
@@ -208,11 +189,11 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		this._register(scopedContextKeyService);
 		CONTEXT_IN_DEBUG_REPL.bindTo(scopedContextKeyService).set(true);
 
-		const scopedInstantiationService = this.instantiationService.createChild(new ServiceCollection(
+		this.scopedInstantiationService = this.instantiationService.createChild(new ServiceCollection(
 			[IContextKeyService, scopedContextKeyService], [IPrivateReplService, this]));
 		const options = getSimpleEditorOptions();
 		options.readOnly = true;
-		this.replInput = scopedInstantiationService.createInstance(CodeEditorWidget, this.replInputContainer, options, getSimpleCodeEditorWidgetOptions());
+		this.replInput = this.scopedInstantiationService.createInstance(CodeEditorWidget, this.replInputContainer, options, getSimpleCodeEditorWidgetOptions());
 
 		modes.CompletionProviderRegistry.register({ scheme: DEBUG_SCHEME, pattern: '**/replinput', hasAccessToAllModels: true }, {
 			triggerCharacters: ['.'],
@@ -265,19 +246,44 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 	}
 
-	public showPreviousValue(): void {
+	showPreviousValue(): void {
 		this.navigateHistory(true);
 	}
 
-	public showNextValue(): void {
+	showNextValue(): void {
 		this.navigateHistory(false);
 	}
 
-	public acceptReplInput(): void {
-		const viewModel = this.debugService.getViewModel();
-		const session = viewModel.focusedSession;
+	selectSession(session: IDebugSession): void {
+		if (this.replElementsChangeListener) {
+			this.replElementsChangeListener.dispose();
+		}
 		if (session) {
-			session.addReplExpression(viewModel.focusedStackFrame, this.replInput.getValue());
+			this.replElementsChangeListener = session.onDidChangeReplElements(() => {
+				this.refreshReplElements(session.getReplElements().length === 0);
+			});
+
+			if (this.tree && this.isVisible() && this.tree.getInput() !== session) {
+				this.tree.setInput(session);
+			}
+		}
+
+		this.replInput.updateOptions({ readOnly: this.isReadonly });
+		if (this.isVisible()) {
+			this.updateInputDecoration();
+		}
+	}
+
+	clearRepl(): void {
+		const session: IDebugSession = this.tree.getInput();
+		session.removeReplExpressions();
+		this.replInput.focus();
+	}
+
+	acceptReplInput(): void {
+		const session: IDebugSession = this.tree.getInput();
+		if (session) {
+			session.addReplExpression(this.debugService.getViewModel().focusedStackFrame, this.replInput.getValue());
 			this.history.add(this.replInput.getValue());
 			this.replInput.setValue('');
 			// Trigger a layout to shrink a potential multi line input
@@ -286,7 +292,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 	}
 
-	public getVisibleContent(): string {
+	getVisibleContent(): string {
 		let text = '';
 		const navigator = this.tree.getNavigator();
 		// skip first navigator element - the root node
@@ -300,7 +306,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return text;
 	}
 
-	public layout(dimension: dom.Dimension): void {
+	layout(dimension: dom.Dimension): void {
 		this.dimension = dimension;
 		if (this.tree) {
 			this.renderer.setWidth(dimension.width - 25, this.characterWidth);
@@ -313,6 +319,16 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		this.replInput.layout({ width: dimension.width - 20, height: this.replInputHeight });
 	}
 
+	get isReadonly(): boolean {
+		// Do not allow to edit inactive sessions
+		const session: IDebugSession = this.tree.getInput();
+		if (session && session.state !== State.Inactive) {
+			return false;
+		}
+
+		return true;
+	}
+
 	@memoize
 	private get characterWidth(): number {
 		const characterWidthSurveyor = dom.append(this.container, $('.surveyor'));
@@ -325,22 +341,22 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return characterWidthSurveyor.clientWidth / characterWidthSurveyor.textContent.length;
 	}
 
-	public focus(): void {
+	focus(): void {
 		this.replInput.focus();
 	}
 
 	getActionItem(action: IAction): IActionItem {
-		if (action.id === FocusSessionAction.ID) {
-			return this.focusSessionActionItem;
+		if (action.id === SelectReplAction.ID) {
+			return this.instantiationService.createInstance(SelectReplActionItem, this.selectReplAction);
 		}
 
 		return undefined;
 	}
 
-	public getActions(): IAction[] {
+	getActions(): IAction[] {
 		const result: IAction[] = [];
-		if (this.debugService.getModel().getSessions().length > 1) {
-			result.push(this.focusSessionAction);
+		if (this.debugService.getModel().getSessions(true).length > 1) {
+			result.push(this.selectReplAction);
 		}
 		result.push(this.clearReplAction);
 
@@ -349,7 +365,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return result;
 	}
 
-	public shutdown(): void {
+	shutdown(): void {
 		const replHistory = this.history.getHistory();
 		if (replHistory.length) {
 			this.storageService.store(HISTORY_STORAGE_KEY, JSON.stringify(replHistory), StorageScope.WORKSPACE);
@@ -359,17 +375,13 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 	}
 
 	@memoize
-	private get focusSessionAction(): FocusSessionAction {
-		return this.instantiationService.createInstance(FocusSessionAction, FocusSessionAction.ID, FocusSessionAction.LABEL);
+	private get selectReplAction(): SelectReplAction {
+		return this.scopedInstantiationService.createInstance(SelectReplAction, SelectReplAction.ID, SelectReplAction.LABEL);
 	}
 
 	@memoize
 	private get clearReplAction(): ClearReplAction {
-		return this.instantiationService.createInstance(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL);
-	}
-
-	private get focusSessionActionItem(): FocusSessionActionItem {
-		return this.instantiationService.createInstance(FocusSessionActionItem, this.focusSessionAction);
+		return this.scopedInstantiationService.createInstance(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL);
 	}
 
 	private updateInputDecoration(): void {
@@ -378,7 +390,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 
 		const decorations: IDecorationOptions[] = [];
-		if (!this.debugService.getViewModel().focusedSession) {
+		if (this.isReadonly) {
 			decorations.push({
 				range: {
 					startLineNumber: 0,
@@ -398,7 +410,7 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		this.replInput.setDecorations(DECORATION_KEY, decorations);
 	}
 
-	public dispose(): void {
+	dispose(): void {
 		this.replInput.dispose();
 		super.dispose();
 	}
@@ -420,7 +432,7 @@ class AcceptReplInputAction extends EditorAction {
 		});
 	}
 
-	public run(accessor: ServicesAccessor, editor: ICodeEditor): void | TPromise<void> {
+	run(accessor: ServicesAccessor, editor: ICodeEditor): void | TPromise<void> {
 		SuggestController.get(editor).acceptSelectedSuggestion();
 		accessor.get(IPrivateReplService).acceptReplInput();
 	}
@@ -437,7 +449,7 @@ export class ReplCopyAllAction extends EditorAction {
 		});
 	}
 
-	public run(accessor: ServicesAccessor, editor: ICodeEditor): void | TPromise<void> {
+	run(accessor: ServicesAccessor, editor: ICodeEditor): void | TPromise<void> {
 		clipboard.writeText(accessor.get(IPrivateReplService).getVisibleContent());
 	}
 }
@@ -456,3 +468,54 @@ registerEditorCommand(new SuggestCommand({
 		primary: KeyCode.RightArrow
 	}
 }));
+
+class SelectReplActionItem extends FocusSessionActionItem {
+	protected getSessions(): ReadonlyArray<IDebugSession> {
+		return this.debugService.getModel().getSessions(true);
+	}
+}
+
+class SelectReplAction extends Action {
+
+	static readonly ID = 'workbench.action.debug.selectRepl';
+	static LABEL = nls.localize('selectRepl', "Select Debug Console");
+
+	constructor(id: string, label: string,
+		@IDebugService private debugService: IDebugService,
+		@IPrivateReplService private replService: IPrivateReplService
+	) {
+		super(id, label);
+	}
+
+	run(sessionName: string): TPromise<any> {
+		const session = this.debugService.getModel().getSessions(true).filter(p => p.getLabel() === sessionName).pop();
+		// If session is already the focused session we need to manualy update the tree since view model will not send a focused change event
+		if (session && session.state !== State.Inactive && session !== this.debugService.getViewModel().focusedSession) {
+			this.debugService.focusStackFrame(undefined, undefined, session, true);
+		} else {
+			this.replService.selectSession(session);
+		}
+
+		return Promise.resolve(undefined);
+	}
+}
+
+class ClearReplAction extends Action {
+	static readonly ID = 'workbench.debug.panel.action.clearReplAction';
+	static LABEL = nls.localize('clearRepl', "Clear Console");
+
+	constructor(id: string, label: string,
+		@IDebugService debugService: IDebugService,
+		@IPrivateReplService private replService: IPrivateReplService
+	) {
+		super(id, label, 'debug-action clear-repl');
+	}
+
+	public run(): TPromise<any> {
+		this.replService.clearRepl();
+		aria.status(nls.localize('debugConsoleCleared', "Debug console was cleared"));
+
+		// focus back to repl
+		return Promise.resolve(undefined);
+	}
+}
diff --git a/src/vs/workbench/parts/debug/electron-browser/replViewer.ts b/src/vs/workbench/parts/debug/electron-browser/replViewer.ts
index fecd8d36b1f..82bf8989a13 100644
--- a/src/vs/workbench/parts/debug/electron-browser/replViewer.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/replViewer.ts
@@ -5,7 +5,7 @@
 
 import * as nls from 'vs/nls';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IAction } from 'vs/base/common/actions';
+import { IAction, Action } from 'vs/base/common/actions';
 import * as lifecycle from 'vs/base/common/lifecycle';
 import { isFullWidthCharacter, removeAnsiEscapeCodes, endsWith } from 'vs/base/common/strings';
 import { IActionItem, Separator } from 'vs/base/browser/ui/actionbar/actionbar';
@@ -17,7 +17,7 @@ import { ICancelableEvent } from 'vs/base/parts/tree/browser/treeDefaults';
 import { IExpressionContainer, IExpression, IReplElementSource } from 'vs/workbench/parts/debug/common/debug';
 import { RawObjectReplElement, Expression, SimpleReplElement, Variable } from 'vs/workbench/parts/debug/common/debugModel';
 import { renderVariable, renderExpressionValue, IVariableTemplateData, BaseDebugController } from 'vs/workbench/parts/debug/browser/baseDebugView';
-import { ClearReplAction, ReplCollapseAllAction } from 'vs/workbench/parts/debug/browser/debugActions';
+import { ReplCollapseAllAction } from 'vs/workbench/parts/debug/browser/debugActions';
 import { CopyAction, CopyAllAction } from 'vs/workbench/parts/debug/electron-browser/electronDebugActions';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
@@ -317,7 +317,7 @@ export class ReplExpressionsAccessibilityProvider implements IAccessibilityProvi
 
 export class ReplExpressionsActionProvider implements IActionProvider {
 
-	constructor(private instantiationService: IInstantiationService, private toFocus: { focus(): void }) {
+	constructor(private clearReplAction: Action, private toFocus: { focus(): void }) {
 		// noop
 	}
 
@@ -339,7 +339,7 @@ export class ReplExpressionsActionProvider implements IActionProvider {
 		actions.push(new CopyAllAction(CopyAllAction.ID, CopyAllAction.LABEL, tree));
 		actions.push(new ReplCollapseAllAction(tree, this.toFocus));
 		actions.push(new Separator());
-		actions.push(this.instantiationService.createInstance(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL));
+		actions.push(this.clearReplAction);
 
 		return Promise.resolve(actions);
 	}
diff --git a/src/vs/workbench/parts/debug/test/common/mockDebug.ts b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
index 09f8cd37c55..36811ef24d1 100644
--- a/src/vs/workbench/parts/debug/test/common/mockDebug.ts
+++ b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
@@ -17,10 +17,6 @@ export class MockDebugService implements IDebugService {
 
 	public _serviceBrand: any;
 
-	getSession(sessionId: string): IDebugSession {
-		return undefined;
-	}
-
 	public get state(): State {
 		return null;
 	}
diff --git a/src/vs/workbench/parts/debug/test/electron-browser/debugModel.test.ts b/src/vs/workbench/parts/debug/test/electron-browser/debugModel.test.ts
index d9fc61272b5..c16ffe8c9de 100644
--- a/src/vs/workbench/parts/debug/test/electron-browser/debugModel.test.ts
+++ b/src/vs/workbench/parts/debug/test/electron-browser/debugModel.test.ts
@@ -113,7 +113,7 @@ suite('Debug - Model', () => {
 		const session = new DebugSession({ resolved: { name: 'mockSession', type: 'node', request: 'launch' }, unresolved: undefined }, undefined, model, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
 		model.addSession(session);
 
-		assert.equal(model.getSessions().length, 1);
+		assert.equal(model.getSessions(true).length, 1);
 		model.rawUpdate({
 			sessionId: session.getId(),
 			threadId: threadId,
@@ -127,9 +127,7 @@ suite('Debug - Model', () => {
 
 		model.clearThreads(session.getId(), true);
 		assert.equal(session.getThread(threadId), null);
-		assert.equal(model.getSessions().length, 1);
-		model.removeSession(session.getId());
-		assert.equal(model.getSessions().length, 0);
+		assert.equal(model.getSessions(true).length, 1);
 	});
 
 	test('threads multiple wtih allThreadsStopped', () => {

From 53321de6d3567a1a696216a47fa38e8f550f8e32 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 12:09:21 +0200
Subject: [PATCH 47/76] fix #60247

---
 .../electron-browser/snippetsService.ts       | 70 ++++++-------------
 .../electron-browser/snippetsService.test.ts  | 51 +++++++++-----
 2 files changed, 55 insertions(+), 66 deletions(-)

diff --git a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
index a63e501486e..afb20204aa9 100644
--- a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
+++ b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
@@ -13,7 +13,7 @@ import { compare, endsWith, isFalsyOrWhitespace } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
 import { Position } from 'vs/editor/common/core/position';
 import { ITextModel } from 'vs/editor/common/model';
-import { CompletionItem, CompletionList, CompletionItemProvider, LanguageId, CompletionContext, CompletionItemKind } from 'vs/editor/common/modes';
+import { CompletionItem, CompletionList, CompletionItemProvider, LanguageId, CompletionItemKind } from 'vs/editor/common/modes';
 import { IModeService } from 'vs/editor/common/services/modeService';
 import { SnippetParser } from 'vs/editor/contrib/snippet/snippetParser';
 import { setSnippetSuggestSupport } from 'vs/editor/contrib/suggest/suggest';
@@ -365,53 +365,35 @@ export class SnippetSuggestProvider implements CompletionItemProvider {
 		//
 	}
 
-	provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext): Promise<CompletionList> {
+	provideCompletionItems(model: ITextModel, pos: Position): Promise<CompletionList> {
 
-		const languageId = this._getLanguageIdAtPosition(model, position);
+		const languageId = this._getLanguageIdAtPosition(model, pos);
 		return this._snippets.getSnippets(languageId).then(snippets => {
 
-			let suggestions: SnippetSuggestion[];
-			let shift = Math.max(0, position.column - 100);
-			let pos = { lineNumber: position.lineNumber, column: Math.max(1, position.column - 100) };
-			let lineOffsets: number[] = [];
-			let linePrefixLow = model.getLineContent(position.lineNumber).substr(Math.max(0, position.column - 100), position.column - 1).toLowerCase();
+			let suggestions: SnippetSuggestion[] = [];
+			let atWord = Boolean(model.getWordAtPosition(pos));
+			let lineLow = model.getLineContent(pos.lineNumber).substring(0, pos.column - 1).toLowerCase();
 
-			while (pos.column < position.column) {
-				let word = model.getWordAtPosition(pos);
-				if (word) {
-					// at a word
-					lineOffsets.push(word.startColumn - 1);
-					pos.column = word.endColumn + 1;
+			for (const snippet of snippets) {
 
-					if (word.endColumn - 1 < linePrefixLow.length && !/\s/.test(linePrefixLow[word.endColumn - 1])) {
-						lineOffsets.push(word.endColumn - 1);
+				let prefixLow = snippet.prefix;
+				let prefixPos = prefixLow.length - 1;
+				let linePos = lineLow.length - 1;
+				let linePosStart = linePos;
+				while (linePos >= 0 && prefixPos >= 0) {
+					if (lineLow[linePos] === prefixLow[prefixPos]) {
+						linePos -= 1;
 					}
-
-				} else if (!/\s/.test(linePrefixLow[pos.column - 1])) {
-					// at a none-whitespace character
-					lineOffsets.push(pos.column - 1);
-					pos.column += 1;
-				} else {
-					// always advance!
-					pos.column += 1;
+					prefixPos -= 1;
 				}
-			}
 
-			if (lineOffsets.length === 0) {
-				// no interesting spans found -> pick all snippets
-				suggestions = snippets.map(snippet => new SnippetSuggestion(snippet, Range.fromPositions(position)));
+				if (linePos !== linePosStart) {
+					// some overlap
+					suggestions.push(new SnippetSuggestion(snippet, Range.fromPositions(pos.delta(0, linePos - linePosStart), pos)));
 
-			} else {
-				let consumed = new Set<Snippet>();
-				suggestions = [];
-				for (let start of lineOffsets) {
-					start -= shift;
-					for (const snippet of snippets) {
-						if (!consumed.has(snippet) && matches(linePrefixLow, start, snippet.prefixLow, 0)) {
-							suggestions.push(new SnippetSuggestion(snippet, Range.fromPositions(position.delta(0, -(linePrefixLow.length - start)), position)));
-							consumed.add(snippet);
-						}
-					}
+				} else if (!atWord) {
+					// no overlap but not at a word
+					suggestions.push(new SnippetSuggestion(snippet, Range.fromPositions(pos)));
 				}
 			}
 
@@ -451,16 +433,6 @@ export class SnippetSuggestProvider implements CompletionItemProvider {
 	}
 }
 
-function matches(pattern: string, patternStart: number, word: string, wordStart: number): boolean {
-	while (patternStart < pattern.length && wordStart < word.length) {
-		if (pattern[patternStart] === word[wordStart]) {
-			patternStart += 1;
-		}
-		wordStart += 1;
-	}
-	return patternStart === pattern.length;
-}
-
 export function getNonWhitespacePrefix(model: ISimpleModel, position: Position): string {
 	/**
 	 * Do not analyze more characters
diff --git a/src/vs/workbench/parts/snippets/test/electron-browser/snippetsService.test.ts b/src/vs/workbench/parts/snippets/test/electron-browser/snippetsService.test.ts
index 37e132671ea..2de580f6a71 100644
--- a/src/vs/workbench/parts/snippets/test/electron-browser/snippetsService.test.ts
+++ b/src/vs/workbench/parts/snippets/test/electron-browser/snippetsService.test.ts
@@ -11,7 +11,6 @@ import { ModeServiceImpl } from 'vs/editor/common/services/modeServiceImpl';
 import { TextModel } from 'vs/editor/common/model/textModel';
 import { ISnippetsService } from 'vs/workbench/parts/snippets/electron-browser/snippets.contribution';
 import { Snippet, SnippetSource } from 'vs/workbench/parts/snippets/electron-browser/snippetsFile';
-import { CompletionContext, CompletionTriggerKind } from 'vs/editor/common/modes';
 
 class SimpleSnippetService implements ISnippetsService {
 	_serviceBrand: any;
@@ -39,7 +38,6 @@ suite('SnippetsService', function () {
 
 	let modeService: ModeServiceImpl;
 	let snippetService: ISnippetsService;
-	let suggestContext: CompletionContext = { triggerKind: CompletionTriggerKind.Invoke };
 
 	setup(function () {
 		modeService = new ModeServiceImpl();
@@ -68,7 +66,7 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 		const model = TextModel.createFromString('', undefined, modeService.getLanguageIdentifier('fooLang'));
 
-		return provider.provideCompletionItems(model, new Position(1, 1), suggestContext).then(result => {
+		return provider.provideCompletionItems(model, new Position(1, 1)).then(result => {
 			assert.equal(result.incomplete, undefined);
 			assert.equal(result.suggestions.length, 2);
 		});
@@ -79,7 +77,7 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 		const model = TextModel.createFromString('bar', undefined, modeService.getLanguageIdentifier('fooLang'));
 
-		return provider.provideCompletionItems(model, new Position(1, 4), suggestContext).then(result => {
+		return provider.provideCompletionItems(model, new Position(1, 4)).then(result => {
 			assert.equal(result.incomplete, undefined);
 			assert.equal(result.suggestions.length, 1);
 			assert.equal(result.suggestions[0].label, 'bar');
@@ -111,7 +109,7 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 		const model = TextModel.createFromString('bar-bar', undefined, modeService.getLanguageIdentifier('fooLang'));
 
-		await provider.provideCompletionItems(model, new Position(1, 3), suggestContext).then(result => {
+		await provider.provideCompletionItems(model, new Position(1, 3)).then(result => {
 			assert.equal(result.incomplete, undefined);
 			assert.equal(result.suggestions.length, 2);
 			assert.equal(result.suggestions[0].label, 'bar');
@@ -122,7 +120,7 @@ suite('SnippetsService', function () {
 			assert.equal(result.suggestions[1].range.startColumn, 1);
 		});
 
-		await provider.provideCompletionItems(model, new Position(1, 5), suggestContext).then(result => {
+		await provider.provideCompletionItems(model, new Position(1, 5)).then(result => {
 			assert.equal(result.incomplete, undefined);
 			assert.equal(result.suggestions.length, 1);
 			assert.equal(result.suggestions[0].label, 'bar-bar');
@@ -130,7 +128,7 @@ suite('SnippetsService', function () {
 			assert.equal(result.suggestions[0].range.startColumn, 1);
 		});
 
-		await provider.provideCompletionItems(model, new Position(1, 6), suggestContext).then(result => {
+		await provider.provideCompletionItems(model, new Position(1, 6)).then(result => {
 			assert.equal(result.incomplete, undefined);
 			assert.equal(result.suggestions.length, 2);
 			assert.equal(result.suggestions[0].label, 'bar');
@@ -156,19 +154,19 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 
 		let model = TextModel.createFromString('\t<?php', undefined, modeService.getLanguageIdentifier('fooLang'));
-		return provider.provideCompletionItems(model, new Position(1, 7), suggestContext).then(result => {
+		return provider.provideCompletionItems(model, new Position(1, 7)).then(result => {
 			assert.equal(result.suggestions.length, 1);
 			model.dispose();
 
 			model = TextModel.createFromString('\t<?', undefined, modeService.getLanguageIdentifier('fooLang'));
-			return provider.provideCompletionItems(model, new Position(1, 4), suggestContext);
+			return provider.provideCompletionItems(model, new Position(1, 4));
 		}).then(result => {
 			assert.equal(result.suggestions.length, 1);
 			assert.equal(result.suggestions[0].range.startColumn, 2);
 			model.dispose();
 
 			model = TextModel.createFromString('a<?', undefined, modeService.getLanguageIdentifier('fooLang'));
-			return provider.provideCompletionItems(model, new Position(1, 4), suggestContext);
+			return provider.provideCompletionItems(model, new Position(1, 4));
 		}).then(result => {
 			assert.equal(result.suggestions.length, 1);
 			assert.equal(result.suggestions[0].range.startColumn, 2);
@@ -191,9 +189,9 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 
 		let model = TextModel.createFromString('<head>\n\t\n>/head>', undefined, modeService.getLanguageIdentifier('fooLang'));
-		return provider.provideCompletionItems(model, new Position(1, 1), suggestContext).then(result => {
+		return provider.provideCompletionItems(model, new Position(1, 1)).then(result => {
 			assert.equal(result.suggestions.length, 1);
-			return provider.provideCompletionItems(model, new Position(2, 2), suggestContext);
+			return provider.provideCompletionItems(model, new Position(2, 2));
 		}).then(result => {
 			assert.equal(result.suggestions.length, 1);
 		});
@@ -221,7 +219,7 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 
 		let model = TextModel.createFromString('', undefined, modeService.getLanguageIdentifier('fooLang'));
-		return provider.provideCompletionItems(model, new Position(1, 1), suggestContext).then(result => {
+		return provider.provideCompletionItems(model, new Position(1, 1)).then(result => {
 			assert.equal(result.suggestions.length, 2);
 			let [first, second] = result.suggestions;
 			assert.equal(first.label, 'first');
@@ -243,13 +241,13 @@ suite('SnippetsService', function () {
 
 		let model = TextModel.createFromString('p-', undefined, modeService.getLanguageIdentifier('fooLang'));
 
-		let result = await provider.provideCompletionItems(model, new Position(1, 2), suggestContext);
+		let result = await provider.provideCompletionItems(model, new Position(1, 2));
 		assert.equal(result.suggestions.length, 1);
 
-		result = await provider.provideCompletionItems(model, new Position(1, 3), suggestContext);
+		result = await provider.provideCompletionItems(model, new Position(1, 3));
 		assert.equal(result.suggestions.length, 1);
 
-		result = await provider.provideCompletionItems(model, new Position(1, 3), { triggerCharacter: '-', triggerKind: CompletionTriggerKind.TriggerCharacter });
+		result = await provider.provideCompletionItems(model, new Position(1, 3));
 		assert.equal(result.suggestions.length, 1);
 	});
 
@@ -267,7 +265,26 @@ suite('SnippetsService', function () {
 		const provider = new SnippetSuggestProvider(modeService, snippetService);
 
 		let model = TextModel.createFromString('Thisisaverylonglinegoingwithmore100bcharactersandthismakesintellisensebecomea Thisisaverylonglinegoingwithmore100bcharactersandthismakesintellisensebecomea b', undefined, modeService.getLanguageIdentifier('fooLang'));
-		let result = await provider.provideCompletionItems(model, new Position(1, 158), suggestContext);
+		let result = await provider.provideCompletionItems(model, new Position(1, 158));
+
+		assert.equal(result.suggestions.length, 1);
+	});
+
+	test('No snippets suggestion beyond character 100 if not at end of line #60247', async function () {
+		snippetService = new SimpleSnippetService([new Snippet(
+			['fooLang'],
+			'bug',
+			'bug',
+			'',
+			'second',
+			'',
+			SnippetSource.User
+		)]);
+
+		const provider = new SnippetSuggestProvider(modeService, snippetService);
+
+		let model = TextModel.createFromString('Thisisaverylonglinegoingwithmore100bcharactersandthismakesintellisensebecomea Thisisaverylonglinegoingwithmore100bcharactersandthismakesintellisensebecomea b text_after_b', undefined, modeService.getLanguageIdentifier('fooLang'));
+		let result = await provider.provideCompletionItems(model, new Position(1, 158));
 
 		assert.equal(result.suggestions.length, 1);
 	});

From ccdbbe13a2befa70b49fe0a8d62cafe57ff7176b Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 12:39:08 +0200
Subject: [PATCH 48/76] debug: make sure to dispose of all sesions on shutdown

---
 src/vs/workbench/parts/debug/common/debugModel.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/vs/workbench/parts/debug/common/debugModel.ts b/src/vs/workbench/parts/debug/common/debugModel.ts
index a27da68f7aa..27eb3321270 100644
--- a/src/vs/workbench/parts/debug/common/debugModel.ts
+++ b/src/vs/workbench/parts/debug/common/debugModel.ts
@@ -1049,6 +1049,7 @@ export class DebugModel implements IDebugModel {
 	}
 
 	public dispose(): void {
+		this.sessions.forEach(s => s.shutdown());
 		this.toDispose = lifecycle.dispose(this.toDispose);
 	}
 }

From 12a0b0e74904dc8f112454fe0bc01914e8011045 Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 12:44:31 +0200
Subject: [PATCH 49/76] repl: fix smoke test, make sure to get proper state
 when becomes visible

---
 .../workbench/parts/debug/electron-browser/repl.ts  | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/vs/workbench/parts/debug/electron-browser/repl.ts b/src/vs/workbench/parts/debug/electron-browser/repl.ts
index c9ebbd28319..d2fe3e0f6ee 100644
--- a/src/vs/workbench/parts/debug/electron-browser/repl.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/repl.ts
@@ -30,7 +30,6 @@ import { IInstantiationService, createDecorator } from 'vs/platform/instantiatio
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { ReplExpressionsRenderer, ReplExpressionsController, ReplExpressionsDataSource, ReplExpressionsActionProvider, ReplExpressionsAccessibilityProvider } from 'vs/workbench/parts/debug/electron-browser/replViewer';
 import { Panel } from 'vs/workbench/browser/panel';
-import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
 import { clipboard } from 'electron';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
@@ -100,7 +99,6 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		@ITelemetryService telemetryService: ITelemetryService,
 		@IInstantiationService private instantiationService: IInstantiationService,
 		@IStorageService private storageService: IStorageService,
-		@IPanelService private panelService: IPanelService,
 		@IThemeService protected themeService: IThemeService,
 		@IModelService private modelService: IModelService,
 		@IContextKeyService private contextKeyService: IContextKeyService,
@@ -116,9 +114,10 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 
 	private registerListeners(): void {
 		this._register(this.debugService.getViewModel().onDidFocusSession(session => {
-			this.selectSession(session);
+			if (this.isVisible()) {
+				this.selectSession(session);
+			}
 		}));
-		this._register(this.panelService.onDidPanelOpen(() => this.refreshReplElements(true)));
 		this._register(this.debugService.onDidNewSession(() => this.updateTitleArea()));
 		this._register(this.themeService.onThemeChange(() => {
 			if (this.isVisible()) {
@@ -263,15 +262,13 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 				this.refreshReplElements(session.getReplElements().length === 0);
 			});
 
-			if (this.tree && this.isVisible() && this.tree.getInput() !== session) {
+			if (this.tree && this.tree.getInput() !== session) {
 				this.tree.setInput(session);
 			}
 		}
 
 		this.replInput.updateOptions({ readOnly: this.isReadonly });
-		if (this.isVisible()) {
-			this.updateInputDecoration();
-		}
+		this.updateInputDecoration();
 	}
 
 	clearRepl(): void {

From 6e6a67a53d665bba574b31ef1e9ea468612ae00e Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 12:53:14 +0200
Subject: [PATCH 50/76] repl: better code grouping

---
 .../parts/debug/electron-browser/repl.ts      | 247 +++++++++---------
 1 file changed, 127 insertions(+), 120 deletions(-)

diff --git a/src/vs/workbench/parts/debug/electron-browser/repl.ts b/src/vs/workbench/parts/debug/electron-browser/repl.ts
index d2fe3e0f6ee..c7152b34dc8 100644
--- a/src/vs/workbench/parts/debug/electron-browser/repl.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/repl.ts
@@ -19,7 +19,6 @@ import { Context as SuggestContext } from 'vs/editor/contrib/suggest/suggest';
 import { SuggestController } from 'vs/editor/contrib/suggest/suggestController';
 import { ITextModel } from 'vs/editor/common/model';
 import { Position } from 'vs/editor/common/core/position';
-import * as modes from 'vs/editor/common/modes';
 import { registerEditorAction, ServicesAccessor, EditorAction, EditorCommand, registerEditorCommand } from 'vs/editor/browser/editorExtensions';
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { MenuId } from 'vs/platform/actions/common/actions';
@@ -50,6 +49,7 @@ import { IDecorationOptions } from 'vs/editor/common/editorCommon';
 import { transparent, editorForeground } from 'vs/platform/theme/common/colorRegistry';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { FocusSessionActionItem } from 'vs/workbench/parts/debug/browser/debugActionItems';
+import { CompletionContext, CompletionList, CompletionProviderRegistry } from 'vs/editor/common/modes';
 
 const $ = dom.$;
 
@@ -74,12 +74,11 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 	_serviceBrand: any;
 
 	private static readonly HALF_WIDTH_TYPICAL = 'n';
-
-	private history: HistoryNavigator<string>;
 	private static readonly REFRESH_DELAY = 500; // delay in ms to refresh the repl for new elements to show
 	private static readonly REPL_INPUT_INITIAL_HEIGHT = 19;
 	private static readonly REPL_INPUT_MAX_HEIGHT = 170;
 
+	private history: HistoryNavigator<string>;
 	private tree: ITree;
 	private renderer: ReplExpressionsRenderer;
 	private container: HTMLElement;
@@ -126,44 +125,6 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}));
 	}
 
-	private refreshReplElements(noDelay: boolean): void {
-		if (this.tree && this.isVisible()) {
-			if (this.refreshTimeoutHandle) {
-				return; // refresh already triggered
-			}
-
-			const delay = noDelay ? 0 : Repl.REFRESH_DELAY;
-			this.refreshTimeoutHandle = setTimeout(() => {
-				this.refreshTimeoutHandle = null;
-				const previousScrollPosition = this.tree.getScrollPosition();
-				this.tree.refresh().then(() => {
-					if (previousScrollPosition === 1) {
-						// Only scroll if we were scrolled all the way down before tree refreshed #10486
-						this.tree.setScrollPosition(1);
-					}
-				}, errors.onUnexpectedError);
-			}, delay);
-		}
-	}
-
-	async create(parent: HTMLElement): Promise<void> {
-		await super.create(parent);
-		this.container = dom.append(parent, $('.repl'));
-		this.treeContainer = dom.append(this.container, $('.repl-tree'));
-		this.createReplInput(this.container);
-
-		this.renderer = this.instantiationService.createInstance(ReplExpressionsRenderer);
-		const controller = this.instantiationService.createInstance(ReplExpressionsController, new ReplExpressionsActionProvider(this.clearReplAction, this.replInput), MenuId.DebugConsoleContext, { openMode: OpenMode.SINGLE_CLICK, clickBehavior: ClickBehavior.ON_MOUSE_UP /* do not change, to preserve focus behaviour in input field */ });
-		controller.toFocusOnClick = this.replInput;
-
-		this.tree = this.instantiationService.createInstance(WorkbenchTree, this.treeContainer, {
-			dataSource: new ReplExpressionsDataSource(),
-			renderer: this.renderer,
-			accessibilityProvider: new ReplExpressionsAccessibilityProvider(),
-			controller
-		}, replTreeOptions);
-	}
-
 	setVisible(visible: boolean): Promise<void> {
 		if (!visible) {
 			dispose(this.model);
@@ -180,58 +141,22 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return super.setVisible(visible);
 	}
 
-	private createReplInput(container: HTMLElement): void {
-		this.replInputContainer = dom.append(container, $('.repl-input-wrapper'));
+	get isReadonly(): boolean {
+		// Do not allow to edit inactive sessions
+		const session: IDebugSession = this.tree.getInput();
+		if (session && session.state !== State.Inactive) {
+			return false;
+		}
 
-		const { scopedContextKeyService, historyNavigationEnablement } = createAndBindHistoryNavigationWidgetScopedContextKeyService(this.contextKeyService, { target: this.replInputContainer, historyNavigator: this });
-		this.historyNavigationEnablement = historyNavigationEnablement;
-		this._register(scopedContextKeyService);
-		CONTEXT_IN_DEBUG_REPL.bindTo(scopedContextKeyService).set(true);
+		return true;
+	}
 
-		this.scopedInstantiationService = this.instantiationService.createChild(new ServiceCollection(
-			[IContextKeyService, scopedContextKeyService], [IPrivateReplService, this]));
-		const options = getSimpleEditorOptions();
-		options.readOnly = true;
-		this.replInput = this.scopedInstantiationService.createInstance(CodeEditorWidget, this.replInputContainer, options, getSimpleCodeEditorWidgetOptions());
+	showPreviousValue(): void {
+		this.navigateHistory(true);
+	}
 
-		modes.CompletionProviderRegistry.register({ scheme: DEBUG_SCHEME, pattern: '**/replinput', hasAccessToAllModels: true }, {
-			triggerCharacters: ['.'],
-			provideCompletionItems: (model: ITextModel, position: Position, _context: modes.CompletionContext, token: CancellationToken): Thenable<modes.CompletionList> => {
-				// Disable history navigation because up and down are used to navigate through the suggest widget
-				this.historyNavigationEnablement.set(false);
-
-				const focusedSession = this.debugService.getViewModel().focusedSession;
-				if (focusedSession && focusedSession.capabilities.supportsCompletionsRequest) {
-
-					const word = this.replInput.getModel().getWordAtPosition(position);
-					const overwriteBefore = word ? word.word.length : 0;
-					const text = this.replInput.getModel().getLineContent(position.lineNumber);
-					const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-					const frameId = focusedStackFrame ? focusedStackFrame.frameId : undefined;
-
-					return focusedSession.completions(frameId, text, position, overwriteBefore).then(suggestions => {
-						return { suggestions };
-					}, err => {
-						return { suggestions: [] };
-					});
-				}
-				return Promise.resolve({ suggestions: [] });
-			}
-		});
-
-		this._register(this.replInput.onDidScrollChange(e => {
-			if (!e.scrollHeightChanged) {
-				return;
-			}
-			this.replInputHeight = Math.max(Repl.REPL_INPUT_INITIAL_HEIGHT, Math.min(Repl.REPL_INPUT_MAX_HEIGHT, e.scrollHeight, this.dimension.height));
-			this.layout(this.dimension);
-		}));
-		this._register(this.replInput.onDidChangeModelContent(() => {
-			this.historyNavigationEnablement.set(this.replInput.getModel().getValue() === '');
-		}));
-
-		this._register(dom.addStandardDisposableListener(this.replInputContainer, dom.EventType.FOCUS, () => dom.addClass(this.replInputContainer, 'synthetic-focus')));
-		this._register(dom.addStandardDisposableListener(this.replInputContainer, dom.EventType.BLUR, () => dom.removeClass(this.replInputContainer, 'synthetic-focus')));
+	showNextValue(): void {
+		this.navigateHistory(false);
 	}
 
 	private navigateHistory(previous: boolean): void {
@@ -245,14 +170,6 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 	}
 
-	showPreviousValue(): void {
-		this.navigateHistory(true);
-	}
-
-	showNextValue(): void {
-		this.navigateHistory(false);
-	}
-
 	selectSession(session: IDebugSession): void {
 		if (this.replElementsChangeListener) {
 			this.replElementsChangeListener.dispose();
@@ -316,28 +233,6 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		this.replInput.layout({ width: dimension.width - 20, height: this.replInputHeight });
 	}
 
-	get isReadonly(): boolean {
-		// Do not allow to edit inactive sessions
-		const session: IDebugSession = this.tree.getInput();
-		if (session && session.state !== State.Inactive) {
-			return false;
-		}
-
-		return true;
-	}
-
-	@memoize
-	private get characterWidth(): number {
-		const characterWidthSurveyor = dom.append(this.container, $('.surveyor'));
-		characterWidthSurveyor.textContent = Repl.HALF_WIDTH_TYPICAL;
-		for (let i = 0; i < 10; i++) {
-			characterWidthSurveyor.textContent += characterWidthSurveyor.textContent;
-		}
-		characterWidthSurveyor.style.fontSize = isMacintosh ? '12px' : '14px';
-
-		return characterWidthSurveyor.clientWidth / characterWidthSurveyor.textContent.length;
-	}
-
 	focus(): void {
 		this.replInput.focus();
 	}
@@ -371,6 +266,19 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		}
 	}
 
+	// --- Cached locals
+	@memoize
+	private get characterWidth(): number {
+		const characterWidthSurveyor = dom.append(this.container, $('.surveyor'));
+		characterWidthSurveyor.textContent = Repl.HALF_WIDTH_TYPICAL;
+		for (let i = 0; i < 10; i++) {
+			characterWidthSurveyor.textContent += characterWidthSurveyor.textContent;
+		}
+		characterWidthSurveyor.style.fontSize = isMacintosh ? '12px' : '14px';
+
+		return characterWidthSurveyor.clientWidth / characterWidthSurveyor.textContent.length;
+	}
+
 	@memoize
 	private get selectReplAction(): SelectReplAction {
 		return this.scopedInstantiationService.createInstance(SelectReplAction, SelectReplAction.ID, SelectReplAction.LABEL);
@@ -381,6 +289,102 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 		return this.scopedInstantiationService.createInstance(ClearReplAction, ClearReplAction.ID, ClearReplAction.LABEL);
 	}
 
+	// --- Creation
+
+	async create(parent: HTMLElement): Promise<void> {
+		await super.create(parent);
+		this.container = dom.append(parent, $('.repl'));
+		this.treeContainer = dom.append(this.container, $('.repl-tree'));
+		this.createReplInput(this.container);
+
+		this.renderer = this.instantiationService.createInstance(ReplExpressionsRenderer);
+		const controller = this.instantiationService.createInstance(ReplExpressionsController, new ReplExpressionsActionProvider(this.clearReplAction, this.replInput), MenuId.DebugConsoleContext, { openMode: OpenMode.SINGLE_CLICK, clickBehavior: ClickBehavior.ON_MOUSE_UP /* do not change, to preserve focus behaviour in input field */ });
+		controller.toFocusOnClick = this.replInput;
+
+		this.tree = this.instantiationService.createInstance(WorkbenchTree, this.treeContainer, {
+			dataSource: new ReplExpressionsDataSource(),
+			renderer: this.renderer,
+			accessibilityProvider: new ReplExpressionsAccessibilityProvider(),
+			controller
+		}, replTreeOptions);
+	}
+
+	private createReplInput(container: HTMLElement): void {
+		this.replInputContainer = dom.append(container, $('.repl-input-wrapper'));
+
+		const { scopedContextKeyService, historyNavigationEnablement } = createAndBindHistoryNavigationWidgetScopedContextKeyService(this.contextKeyService, { target: this.replInputContainer, historyNavigator: this });
+		this.historyNavigationEnablement = historyNavigationEnablement;
+		this._register(scopedContextKeyService);
+		CONTEXT_IN_DEBUG_REPL.bindTo(scopedContextKeyService).set(true);
+
+		this.scopedInstantiationService = this.instantiationService.createChild(new ServiceCollection(
+			[IContextKeyService, scopedContextKeyService], [IPrivateReplService, this]));
+		const options = getSimpleEditorOptions();
+		options.readOnly = true;
+		this.replInput = this.scopedInstantiationService.createInstance(CodeEditorWidget, this.replInputContainer, options, getSimpleCodeEditorWidgetOptions());
+
+		CompletionProviderRegistry.register({ scheme: DEBUG_SCHEME, pattern: '**/replinput', hasAccessToAllModels: true }, {
+			triggerCharacters: ['.'],
+			provideCompletionItems: (model: ITextModel, position: Position, _context: CompletionContext, token: CancellationToken): Thenable<CompletionList> => {
+				// Disable history navigation because up and down are used to navigate through the suggest widget
+				this.historyNavigationEnablement.set(false);
+
+				const focusedSession = this.debugService.getViewModel().focusedSession;
+				if (focusedSession && focusedSession.capabilities.supportsCompletionsRequest) {
+
+					const word = this.replInput.getModel().getWordAtPosition(position);
+					const overwriteBefore = word ? word.word.length : 0;
+					const text = this.replInput.getModel().getLineContent(position.lineNumber);
+					const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+					const frameId = focusedStackFrame ? focusedStackFrame.frameId : undefined;
+
+					return focusedSession.completions(frameId, text, position, overwriteBefore).then(suggestions => {
+						return { suggestions };
+					}, err => {
+						return { suggestions: [] };
+					});
+				}
+				return Promise.resolve({ suggestions: [] });
+			}
+		});
+
+		this._register(this.replInput.onDidScrollChange(e => {
+			if (!e.scrollHeightChanged) {
+				return;
+			}
+			this.replInputHeight = Math.max(Repl.REPL_INPUT_INITIAL_HEIGHT, Math.min(Repl.REPL_INPUT_MAX_HEIGHT, e.scrollHeight, this.dimension.height));
+			this.layout(this.dimension);
+		}));
+		this._register(this.replInput.onDidChangeModelContent(() => {
+			this.historyNavigationEnablement.set(this.replInput.getModel().getValue() === '');
+		}));
+
+		this._register(dom.addStandardDisposableListener(this.replInputContainer, dom.EventType.FOCUS, () => dom.addClass(this.replInputContainer, 'synthetic-focus')));
+		this._register(dom.addStandardDisposableListener(this.replInputContainer, dom.EventType.BLUR, () => dom.removeClass(this.replInputContainer, 'synthetic-focus')));
+	}
+
+	// --- Update
+
+	private refreshReplElements(noDelay: boolean): void {
+		if (this.tree && this.isVisible()) {
+			if (this.refreshTimeoutHandle) {
+				return; // refresh already triggered
+			}
+
+			const delay = noDelay ? 0 : Repl.REFRESH_DELAY;
+			this.refreshTimeoutHandle = setTimeout(() => {
+				this.refreshTimeoutHandle = null;
+				const previousScrollPosition = this.tree.getScrollPosition();
+				this.tree.refresh().then(() => {
+					if (previousScrollPosition === 1) {
+						// Only scroll if we were scrolled all the way down before tree refreshed #10486
+						this.tree.setScrollPosition(1);
+					}
+				}, errors.onUnexpectedError);
+			}, delay);
+		}
+	}
+
 	private updateInputDecoration(): void {
 		if (!this.replInput) {
 			return;
@@ -409,6 +413,9 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 
 	dispose(): void {
 		this.replInput.dispose();
+		if (this.replElementsChangeListener) {
+			this.replElementsChangeListener.dispose();
+		}
 		super.dispose();
 	}
 }

From 1f83a8d105ca9c99f496c5cf26a32e9f905cae01 Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 13:06:46 +0200
Subject: [PATCH 51/76] debugSession: simplify return types where not used

---
 src/vs/workbench/parts/debug/common/debug.ts  | 22 ++++-----
 .../parts/debug/common/debugModel.ts          |  2 +-
 .../debug/electron-browser/debugSession.ts    | 46 +++++++++----------
 .../parts/debug/test/common/mockDebug.ts      | 22 ++++-----
 4 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/src/vs/workbench/parts/debug/common/debug.ts b/src/vs/workbench/parts/debug/common/debug.ts
index addce369d6c..3ae4ba92f13 100644
--- a/src/vs/workbench/parts/debug/common/debug.ts
+++ b/src/vs/workbench/parts/debug/common/debug.ts
@@ -183,13 +183,13 @@ export interface IDebugSession extends ITreeElement {
 
 	initialize(dbgr: IDebugger): TPromise<void>;
 	launchOrAttach(config: IConfig): TPromise<void>;
-	restart(): TPromise<DebugProtocol.RestartResponse>;
+	restart(): TPromise<void>;
 	terminate(restart?: boolean /* false */): TPromise<void>;
 	disconnect(restart?: boolean /* false */): TPromise<void>;
 
 	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints | undefined>;
 	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints | undefined>;
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any>;
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void>;
 
 	stackTrace(threadId: number, startFrame: number, levels: number): TPromise<DebugProtocol.StackTraceResponse>;
 	exceptionInfo(threadId: number): TPromise<IExceptionInfo>;
@@ -198,15 +198,15 @@ export interface IDebugSession extends ITreeElement {
 	evaluate(expression: string, frameId?: number, context?: string): TPromise<DebugProtocol.EvaluateResponse>;
 	customRequest(request: string, args: any): TPromise<DebugProtocol.Response>;
 
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse>;
-	next(threadId: number): TPromise<DebugProtocol.NextResponse>;
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse>;
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse>;
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse>;
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse>;
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse>;
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse>;
-	terminateThreads(threadIds: number[]): TPromise<DebugProtocol.TerminateThreadsResponse>;
+	restartFrame(frameId: number, threadId: number): TPromise<void>;
+	next(threadId: number): TPromise<void>;
+	stepIn(threadId: number): TPromise<void>;
+	stepOut(threadId: number): TPromise<void>;
+	stepBack(threadId: number): TPromise<void>;
+	continue(threadId: number): TPromise<void>;
+	reverseContinue(threadId: number): TPromise<void>;
+	pause(threadId: number): TPromise<void>;
+	terminateThreads(threadIds: number[]): TPromise<void>;
 
 	completions(frameId: number, text: string, position: Position, overwriteBefore: number): TPromise<CompletionItem[]>;
 	setVariable(variablesReference: number, name: string, value: string): TPromise<DebugProtocol.SetVariableResponse>;
diff --git a/src/vs/workbench/parts/debug/common/debugModel.ts b/src/vs/workbench/parts/debug/common/debugModel.ts
index 27eb3321270..fff0e7352d5 100644
--- a/src/vs/workbench/parts/debug/common/debugModel.ts
+++ b/src/vs/workbench/parts/debug/common/debugModel.ts
@@ -376,7 +376,7 @@ export class StackFrame implements IStackFrame {
 		});
 	}
 
-	public restart(): TPromise<any> {
+	public restart(): TPromise<void> {
 		return this.thread.session.restartFrame(this.frameId, this.thread.threadId);
 	}
 
diff --git a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
index bb9731a3d7c..096260921cc 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
@@ -165,7 +165,7 @@ export class DebugSession implements IDebugSession {
 						supportsVariablePaging: true, // #9537
 						supportsRunInTerminalRequest: true, // #10574
 						locale: platform.locale
-					}).then(response => {
+					}).then(() => {
 						this.model.addSession(this);
 						this._onDidChangeState.fire();
 						this.model.setExceptionBreakpoints(this.raw.capabilities.exceptionBreakpointFilters);
@@ -223,9 +223,9 @@ export class DebugSession implements IDebugSession {
 	/**
 	 * restart debug adapter session
 	 */
-	restart(): TPromise<DebugProtocol.RestartResponse> {
+	restart(): TPromise<void> {
 		if (this.raw) {
-			return this.raw.restart();
+			return this.raw.restart().then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
@@ -293,10 +293,10 @@ export class DebugSession implements IDebugSession {
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any> {
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void> {
 		if (this.raw) {
 			if (this.raw.readyForBreakpoints) {
-				return this.raw.setExceptionBreakpoints({ filters: exbpts.map(exb => exb.filter) });
+				return this.raw.setExceptionBreakpoints({ filters: exbpts.map(exb => exb.filter) }).then(() => undefined);
 			}
 			return Promise.resolve(null);
 		}
@@ -355,65 +355,65 @@ export class DebugSession implements IDebugSession {
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse> {
+	restartFrame(frameId: number, threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.restartFrame({ frameId }, threadId);
+			return this.raw.restartFrame({ frameId }, threadId).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	next(threadId: number): TPromise<DebugProtocol.NextResponse> {
+	next(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.next({ threadId });
+			return this.raw.next({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse> {
+	stepIn(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepIn({ threadId });
+			return this.raw.stepIn({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse> {
+	stepOut(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepOut({ threadId });
+			return this.raw.stepOut({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse> {
+	stepBack(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepBack({ threadId });
+			return this.raw.stepBack({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse> {
+	continue(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.continue({ threadId });
+			return this.raw.continue({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse> {
+	reverseContinue(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.reverseContinue({ threadId });
+			return this.raw.reverseContinue({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse> {
+	pause(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.pause({ threadId });
+			return this.raw.pause({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	terminateThreads(threadIds?: number[]): TPromise<DebugProtocol.TerminateThreadsResponse> {
+	terminateThreads(threadIds?: number[]): TPromise<void> {
 		if (this.raw) {
-			return this.raw.terminateThreads({ threadIds });
+			return this.raw.terminateThreads({ threadIds }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
diff --git a/src/vs/workbench/parts/debug/test/common/mockDebug.ts b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
index 36811ef24d1..6bffd5e09fa 100644
--- a/src/vs/workbench/parts/debug/test/common/mockDebug.ts
+++ b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
@@ -206,7 +206,7 @@ export class MockSession implements IDebugSession {
 	launchOrAttach(config: IConfig): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	restart(): TPromise<DebugProtocol.RestartResponse> {
+	restart(): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints> {
@@ -215,7 +215,7 @@ export class MockSession implements IDebugSession {
 	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints> {
 		throw new Error('Method not implemented.');
 	}
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any> {
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	customRequest(request: string, args: any): TPromise<DebugProtocol.Response> {
@@ -236,31 +236,31 @@ export class MockSession implements IDebugSession {
 	evaluate(expression: string, frameId: number, context?: string): TPromise<DebugProtocol.EvaluateResponse> {
 		throw new Error('Method not implemented.');
 	}
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse> {
+	restartFrame(frameId: number, threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	next(threadId: number): TPromise<DebugProtocol.NextResponse> {
+	next(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse> {
+	stepIn(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse> {
+	stepOut(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse> {
+	stepBack(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse> {
+	continue(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse> {
+	reverseContinue(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse> {
+	pause(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	terminateThreads(threadIds: number[]): TPromise<DebugProtocol.TerminateThreadsResponse> {
+	terminateThreads(threadIds: number[]): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	setVariable(variablesReference: number, name: string, value: string): TPromise<DebugProtocol.SetVariableResponse> {

From f4ed8a58d9b164c6f81b149d6a9e51f974f3ff57 Mon Sep 17 00:00:00 2001
From: MaxGrosshandler <maxgrosshandler@gmail.com>
Date: Tue, 9 Oct 2018 06:58:18 -0500
Subject: [PATCH 52/76] include reference to the usefulness of the built-in
 reporting tool (#60025)

Originally this was just going to be changing `Report Issues` to `Report Issue` (in VSCode, it's the singular not the plural) and I found myself appreciating the said tool and wondering why the contributing guidelines didn't mention how helpful it could be, so I wanted to remedy that
---
 CONTRIBUTING.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4d8ba5500ae..46afac5dfe4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -48,12 +48,13 @@ Do not add your issue as a comment to an existing issue unless it's for the iden
 
 The more information you can provide, the more likely someone will be successful at reproducing the issue and finding a fix.
 
+The built-in tool for reporting an issue, which you can access by using `Report Issue` in VS Code's Help menu, can help streamline this process by automatically providing the version of VS Code, all your installed extensions, and your system info. Additionally, the tool will search among existing issues to see if a similar issue already exists.
+
 Please include the following with each issue:
 
 * Version of VS Code
 
 * List of extensions that you have installed.
-  * **Tip:** You can easily add the list of extensions by creating the issue using `Report Issues` from VS Code's Help menu
 
 * Reproducible steps (1... 2... 3...) that cause the issue
 

From 1de8905bf5c0e26170aff0d7b3332de9f9f5ffe3 Mon Sep 17 00:00:00 2001
From: benjamenhogben <bhogben@gmail.com>
Date: Tue, 9 Oct 2018 14:07:13 +0100
Subject: [PATCH 53/76] Change throwable var name

---
 extensions/php/snippets/php.snippets.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extensions/php/snippets/php.snippets.json b/extensions/php/snippets/php.snippets.json
index f964dc42a01..1f2a07bef20 100644
--- a/extensions/php/snippets/php.snippets.json
+++ b/extensions/php/snippets/php.snippets.json
@@ -254,7 +254,7 @@
 		"body": [
 			"try {",
 			"\t${1://code...}",
-			"} catch (${2:\\Throwable} ${3:$$t}) {",
+			"} catch (${2:\\Throwable} ${3:$$th}) {",
 			"\t${4://throw $$th;}",
 			"}"
 		],

From c94bc234499be19db23e2cdede8fcf26f3896cff Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 15:24:17 +0200
Subject: [PATCH 54/76] cached data for extensions, second try

---
 src/vs/loader.js                              | 95 ++++++++++---------
 .../electron-browser/extensionHost.ts         |  3 +-
 2 files changed, 51 insertions(+), 47 deletions(-)

diff --git a/src/vs/loader.js b/src/vs/loader.js
index 04a325a8874..4f44a01db19 100644
--- a/src/vs/loader.js
+++ b/src/vs/loader.js
@@ -19,10 +19,11 @@
  *---------------------------------------------------------------------------------------------
  *--------------------------------------------------------------------------------------------*/
 var _amdLoaderGlobal = this;
+var _commonjsGlobal = typeof global === 'object' ? global : {};
 var AMDLoader;
 (function (AMDLoader) {
     AMDLoader.global = _amdLoaderGlobal;
-    var Environment = /** @class */ (function () {
+    var Environment = (function () {
         function Environment() {
             this._detected = false;
             this._isWindows = false;
@@ -93,7 +94,7 @@ var AMDLoader;
  *--------------------------------------------------------------------------------------------*/
 var AMDLoader;
 (function (AMDLoader) {
-    var LoaderEvent = /** @class */ (function () {
+    var LoaderEvent = (function () {
         function LoaderEvent(type, detail, timestamp) {
             this.type = type;
             this.detail = detail;
@@ -102,7 +103,7 @@ var AMDLoader;
         return LoaderEvent;
     }());
     AMDLoader.LoaderEvent = LoaderEvent;
-    var LoaderEventRecorder = /** @class */ (function () {
+    var LoaderEventRecorder = (function () {
         function LoaderEventRecorder(loaderAvailableTimestamp) {
             this._events = [new LoaderEvent(1 /* LoaderAvailable */, '', loaderAvailableTimestamp)];
         }
@@ -115,7 +116,7 @@ var AMDLoader;
         return LoaderEventRecorder;
     }());
     AMDLoader.LoaderEventRecorder = LoaderEventRecorder;
-    var NullLoaderEventRecorder = /** @class */ (function () {
+    var NullLoaderEventRecorder = (function () {
         function NullLoaderEventRecorder() {
         }
         NullLoaderEventRecorder.prototype.record = function (type, detail) {
@@ -124,9 +125,9 @@ var AMDLoader;
         NullLoaderEventRecorder.prototype.getEvents = function () {
             return [];
         };
-        NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();
         return NullLoaderEventRecorder;
     }());
+    NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();
     AMDLoader.NullLoaderEventRecorder = NullLoaderEventRecorder;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -135,7 +136,7 @@ var AMDLoader;
  *--------------------------------------------------------------------------------------------*/
 var AMDLoader;
 (function (AMDLoader) {
-    var Utilities = /** @class */ (function () {
+    var Utilities = (function () {
         function Utilities() {
         }
         /**
@@ -221,11 +222,11 @@ var AMDLoader;
             }
             return (this.HAS_PERFORMANCE_NOW ? AMDLoader.global.performance.now() : Date.now());
         };
-        Utilities.NEXT_ANONYMOUS_ID = 1;
-        Utilities.PERFORMANCE_NOW_PROBED = false;
-        Utilities.HAS_PERFORMANCE_NOW = false;
         return Utilities;
     }());
+    Utilities.NEXT_ANONYMOUS_ID = 1;
+    Utilities.PERFORMANCE_NOW_PROBED = false;
+    Utilities.HAS_PERFORMANCE_NOW = false;
     AMDLoader.Utilities = Utilities;
 })(AMDLoader || (AMDLoader = {}));
 /*---------------------------------------------------------------------------------------------
@@ -234,7 +235,7 @@ var AMDLoader;
  *--------------------------------------------------------------------------------------------*/
 var AMDLoader;
 (function (AMDLoader) {
-    var ConfigurationOptionsUtil = /** @class */ (function () {
+    var ConfigurationOptionsUtil = (function () {
         function ConfigurationOptionsUtil() {
         }
         /**
@@ -343,7 +344,7 @@ var AMDLoader;
         return ConfigurationOptionsUtil;
     }());
     AMDLoader.ConfigurationOptionsUtil = ConfigurationOptionsUtil;
-    var Configuration = /** @class */ (function () {
+    var Configuration = (function () {
         function Configuration(env, options) {
             this._env = env;
             this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);
@@ -554,7 +555,7 @@ var AMDLoader;
     /**
      * Load `scriptSrc` only once (avoid multiple <script> tags)
      */
-    var OnlyOnceScriptLoader = /** @class */ (function () {
+    var OnlyOnceScriptLoader = (function () {
         function OnlyOnceScriptLoader(env) {
             this._env = env;
             this._scriptLoader = null;
@@ -596,7 +597,7 @@ var AMDLoader;
         };
         return OnlyOnceScriptLoader;
     }());
-    var BrowserScriptLoader = /** @class */ (function () {
+    var BrowserScriptLoader = (function () {
         function BrowserScriptLoader() {
         }
         /**
@@ -634,7 +635,7 @@ var AMDLoader;
         };
         return BrowserScriptLoader;
     }());
-    var WorkerScriptLoader = /** @class */ (function () {
+    var WorkerScriptLoader = (function () {
         function WorkerScriptLoader() {
         }
         WorkerScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
@@ -648,7 +649,7 @@ var AMDLoader;
         };
         return WorkerScriptLoader;
     }());
-    var NodeScriptLoader = /** @class */ (function () {
+    var NodeScriptLoader = (function () {
         function NodeScriptLoader(env) {
             this._env = env;
             this._didInitialize = false;
@@ -719,7 +720,7 @@ var AMDLoader;
                 var compileWrapper = script.runInThisContext(options);
                 var dirname = that._path.dirname(filename);
                 var require = makeRequireFunction(this);
-                var args = [this.exports, require, this, filename, dirname, process, AMDLoader.global, Buffer];
+                var args = [this.exports, require, this, filename, dirname, process, _commonjsGlobal, Buffer];
                 var result = compileWrapper.apply(this.exports, args);
                 that._processCachedData(moduleManager, script, cachedDataPath);
                 return result;
@@ -830,15 +831,17 @@ var AMDLoader;
                     errorCode: 'cachedDataRejected',
                     path: cachedDataPath
                 });
-                NodeScriptLoader._runSoon(function () { return _this._fs.unlink(cachedDataPath, function (err) {
-                    if (err) {
-                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
-                            errorCode: 'unlink',
-                            path: cachedDataPath,
-                            detail: err
-                        });
-                    }
-                }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
+                NodeScriptLoader._runSoon(function () {
+                    return _this._fs.unlink(cachedDataPath, function (err) {
+                        if (err) {
+                            moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
+                                errorCode: 'unlink',
+                                path: cachedDataPath,
+                                detail: err
+                            });
+                        }
+                    });
+                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
             }
             else if (script.cachedDataProduced) {
                 // data produced => tell outside world
@@ -847,24 +850,26 @@ var AMDLoader;
                     length: script.cachedData.length
                 });
                 // data produced => write cache file
-                NodeScriptLoader._runSoon(function () { return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {
-                    if (err) {
-                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
-                            errorCode: 'writeFile',
-                            path: cachedDataPath,
-                            detail: err
-                        });
-                    }
-                }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
+                NodeScriptLoader._runSoon(function () {
+                    return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {
+                        if (err) {
+                            moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
+                                errorCode: 'writeFile',
+                                path: cachedDataPath,
+                                detail: err
+                            });
+                        }
+                    });
+                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
             }
         };
         NodeScriptLoader._runSoon = function (callback, minTimeout) {
             var timeout = minTimeout + Math.ceil(Math.random() * minTimeout);
             setTimeout(callback, timeout);
         };
-        NodeScriptLoader._BOM = 0xFEFF;
         return NodeScriptLoader;
     }());
+    NodeScriptLoader._BOM = 0xFEFF;
     function createScriptLoader(env) {
         return new OnlyOnceScriptLoader(env);
     }
@@ -878,7 +883,7 @@ var AMDLoader;
 (function (AMDLoader) {
     // ------------------------------------------------------------------------
     // ModuleIdResolver
-    var ModuleIdResolver = /** @class */ (function () {
+    var ModuleIdResolver = (function () {
         function ModuleIdResolver(fromModuleId) {
             var lastSlash = fromModuleId.lastIndexOf('/');
             if (lastSlash !== -1) {
@@ -921,13 +926,13 @@ var AMDLoader;
             }
             return result;
         };
-        ModuleIdResolver.ROOT = new ModuleIdResolver('');
         return ModuleIdResolver;
     }());
+    ModuleIdResolver.ROOT = new ModuleIdResolver('');
     AMDLoader.ModuleIdResolver = ModuleIdResolver;
     // ------------------------------------------------------------------------
     // Module
-    var Module = /** @class */ (function () {
+    var Module = (function () {
         function Module(id, strId, dependencies, callback, errorback, moduleIdResolver) {
             this.id = id;
             this.strId = strId;
@@ -1017,7 +1022,7 @@ var AMDLoader;
         return Module;
     }());
     AMDLoader.Module = Module;
-    var ModuleIdProvider = /** @class */ (function () {
+    var ModuleIdProvider = (function () {
         function ModuleIdProvider() {
             this._nextId = 0;
             this._strModuleIdToIntModuleId = new Map();
@@ -1044,17 +1049,17 @@ var AMDLoader;
         };
         return ModuleIdProvider;
     }());
-    var RegularDependency = /** @class */ (function () {
+    var RegularDependency = (function () {
         function RegularDependency(id) {
             this.id = id;
         }
-        RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);
-        RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);
-        RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);
         return RegularDependency;
     }());
+    RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);
+    RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);
+    RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);
     AMDLoader.RegularDependency = RegularDependency;
-    var PluginDependency = /** @class */ (function () {
+    var PluginDependency = (function () {
         function PluginDependency(id, pluginId, pluginParam) {
             this.id = id;
             this.pluginId = pluginId;
@@ -1063,7 +1068,7 @@ var AMDLoader;
         return PluginDependency;
     }());
     AMDLoader.PluginDependency = PluginDependency;
-    var ModuleManager = /** @class */ (function () {
+    var ModuleManager = (function () {
         function ModuleManager(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp) {
             if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }
             this._env = env;
diff --git a/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts b/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
index bab147b26dc..98612acf46d 100644
--- a/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
+++ b/src/vs/workbench/services/extensions/electron-browser/extensionHost.ts
@@ -177,8 +177,7 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 						VSCODE_IPC_HOOK_EXTHOST: pipeName,
 						VSCODE_HANDLES_UNCAUGHT_ERRORS: true,
 						VSCODE_LOG_STACK: !this._isExtensionDevTestFromCli && (this._isExtensionDevHost || !this._environmentService.isBuilt || product.quality !== 'stable' || this._environmentService.verbose),
-						VSCODE_LOG_LEVEL: this._environmentService.verbose ? 'trace' : this._environmentService.log,
-						VSCODE_NODE_CACHED_DATA_DIR: ''
+						VSCODE_LOG_LEVEL: this._environmentService.verbose ? 'trace' : this._environmentService.log
 					}),
 					// We only detach the extension host on windows. Linux and Mac orphan by default
 					// and detach under Linux and Mac create another process group.

From f255d10339412724fc643490262e82dc4c119743 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 15:36:55 +0200
Subject: [PATCH 55/76] fix #60188

---
 .../electron-browser/snippetsService.ts       | 70 ++++++++++---------
 1 file changed, 37 insertions(+), 33 deletions(-)

diff --git a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
index afb20204aa9..c7a8387bfb3 100644
--- a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
+++ b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
@@ -31,7 +31,7 @@ import { IWorkspaceContextService, IWorkspace } from 'vs/platform/workspace/comm
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
 import { IRange, Range } from 'vs/editor/common/core/range';
 
-namespace schema {
+namespace ext {
 
 	export interface ISnippetsExtensionPoint {
 		language: string;
@@ -109,6 +109,12 @@ namespace schema {
 			}
 		}
 	};
+
+	export let snippetExtensions: ReadonlyArray<IExtensionPointUser<ISnippetsExtensionPoint[]>> = [];
+
+	ExtensionsRegistry.registerExtensionPoint<ext.ISnippetsExtensionPoint[]>('snippets', [languagesExtPoint], ext.snippetsContribution).setHandler(extensions => {
+		snippetExtensions = snippetExtensions.concat(extensions);
+	});
 }
 
 function watch(service: IFileService, resource: URI, callback: (type: FileChangeType, resource: URI) => any): IDisposable {
@@ -144,8 +150,8 @@ class SnippetsService implements ISnippetsService {
 		@IFileService private readonly _fileService: IFileService,
 		@ILifecycleService lifecycleService: ILifecycleService,
 	) {
-		this._initExtensionSnippets();
 		this._pendingWork.push(Promise.resolve(lifecycleService.when(LifecyclePhase.Running).then(() => {
+			this._initExtensionSnippets();
 			this._initUserSnippets();
 			this._initWorkspaceSnippets();
 		})));
@@ -197,45 +203,43 @@ class SnippetsService implements ISnippetsService {
 	// --- loading, watching
 
 	private _initExtensionSnippets(): void {
-		ExtensionsRegistry.registerExtensionPoint<schema.ISnippetsExtensionPoint[]>('snippets', [languagesExtPoint], schema.snippetsContribution).setHandler(extensions => {
-			for (const extension of extensions) {
-				for (const contribution of extension.value) {
-					const validContribution = schema.toValidSnippet(extension, contribution, this._modeService);
-					if (!validContribution) {
-						continue;
-					}
+		for (const extension of ext.snippetExtensions) {
+			for (const contribution of extension.value) {
+				const validContribution = ext.toValidSnippet(extension, contribution, this._modeService);
+				if (!validContribution) {
+					continue;
+				}
 
-					if (this._files.has(validContribution.location.toString())) {
-						this._files.get(validContribution.location.toString()).defaultScopes.push(validContribution.language);
+				if (this._files.has(validContribution.location.toString())) {
+					this._files.get(validContribution.location.toString()).defaultScopes.push(validContribution.language);
 
-					} else {
-						const file = new SnippetFile(SnippetSource.Extension, validContribution.location, validContribution.language ? [validContribution.language] : undefined, extension.description, this._fileService);
-						this._files.set(file.location.toString(), file);
+				} else {
+					const file = new SnippetFile(SnippetSource.Extension, validContribution.location, validContribution.language ? [validContribution.language] : undefined, extension.description, this._fileService);
+					this._files.set(file.location.toString(), file);
 
-						if (this._environmentService.isExtensionDevelopment) {
-							file.load().then(file => {
-								// warn about bad tabstop/variable usage
-								if (file.data.some(snippet => snippet.isBogous)) {
-									extension.collector.warn(localize(
-										'badVariableUse',
-										"One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
-										extension.description.name
-									));
-								}
-							}, err => {
-								// generic error
+					if (this._environmentService.isExtensionDevelopment) {
+						file.load().then(file => {
+							// warn about bad tabstop/variable usage
+							if (file.data.some(snippet => snippet.isBogous)) {
 								extension.collector.warn(localize(
-									'badFile',
-									"The snippet file \"{0}\" could not be read.",
-									file.location.toString()
+									'badVariableUse',
+									"One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
+									extension.description.name
 								));
-							});
-						}
-
+							}
+						}, err => {
+							// generic error
+							extension.collector.warn(localize(
+								'badFile',
+								"The snippet file \"{0}\" could not be read.",
+								file.location.toString()
+							));
+						});
 					}
+
 				}
 			}
-		});
+		}
 	}
 
 	private _initWorkspaceSnippets(): void {

From 0ec0abe7834a90e2b7293128d753f5d116f1c9b7 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 15:41:03 +0200
Subject: [PATCH 56/76] better fix for #60188

---
 .../electron-browser/snippetsService.ts       | 76 +++++++++----------
 1 file changed, 37 insertions(+), 39 deletions(-)

diff --git a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
index c7a8387bfb3..58f4794f4c5 100644
--- a/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
+++ b/src/vs/workbench/parts/snippets/electron-browser/snippetsService.ts
@@ -31,7 +31,7 @@ import { IWorkspaceContextService, IWorkspace } from 'vs/platform/workspace/comm
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
 import { IRange, Range } from 'vs/editor/common/core/range';
 
-namespace ext {
+namespace snippetExt {
 
 	export interface ISnippetsExtensionPoint {
 		language: string;
@@ -110,11 +110,7 @@ namespace ext {
 		}
 	};
 
-	export let snippetExtensions: ReadonlyArray<IExtensionPointUser<ISnippetsExtensionPoint[]>> = [];
-
-	ExtensionsRegistry.registerExtensionPoint<ext.ISnippetsExtensionPoint[]>('snippets', [languagesExtPoint], ext.snippetsContribution).setHandler(extensions => {
-		snippetExtensions = snippetExtensions.concat(extensions);
-	});
+	export const point = ExtensionsRegistry.registerExtensionPoint<snippetExt.ISnippetsExtensionPoint[]>('snippets', [languagesExtPoint], snippetExt.snippetsContribution);
 }
 
 function watch(service: IFileService, resource: URI, callback: (type: FileChangeType, resource: URI) => any): IDisposable {
@@ -203,43 +199,45 @@ class SnippetsService implements ISnippetsService {
 	// --- loading, watching
 
 	private _initExtensionSnippets(): void {
-		for (const extension of ext.snippetExtensions) {
-			for (const contribution of extension.value) {
-				const validContribution = ext.toValidSnippet(extension, contribution, this._modeService);
-				if (!validContribution) {
-					continue;
-				}
-
-				if (this._files.has(validContribution.location.toString())) {
-					this._files.get(validContribution.location.toString()).defaultScopes.push(validContribution.language);
-
-				} else {
-					const file = new SnippetFile(SnippetSource.Extension, validContribution.location, validContribution.language ? [validContribution.language] : undefined, extension.description, this._fileService);
-					this._files.set(file.location.toString(), file);
-
-					if (this._environmentService.isExtensionDevelopment) {
-						file.load().then(file => {
-							// warn about bad tabstop/variable usage
-							if (file.data.some(snippet => snippet.isBogous)) {
-								extension.collector.warn(localize(
-									'badVariableUse',
-									"One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
-									extension.description.name
-								));
-							}
-						}, err => {
-							// generic error
-							extension.collector.warn(localize(
-								'badFile',
-								"The snippet file \"{0}\" could not be read.",
-								file.location.toString()
-							));
-						});
+		snippetExt.point.setHandler(extensions => {
+			for (const extension of extensions) {
+				for (const contribution of extension.value) {
+					const validContribution = snippetExt.toValidSnippet(extension, contribution, this._modeService);
+					if (!validContribution) {
+						continue;
 					}
 
+					if (this._files.has(validContribution.location.toString())) {
+						this._files.get(validContribution.location.toString()).defaultScopes.push(validContribution.language);
+
+					} else {
+						const file = new SnippetFile(SnippetSource.Extension, validContribution.location, validContribution.language ? [validContribution.language] : undefined, extension.description, this._fileService);
+						this._files.set(file.location.toString(), file);
+
+						if (this._environmentService.isExtensionDevelopment) {
+							file.load().then(file => {
+								// warn about bad tabstop/variable usage
+								if (file.data.some(snippet => snippet.isBogous)) {
+									extension.collector.warn(localize(
+										'badVariableUse',
+										"One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
+										extension.description.name
+									));
+								}
+							}, err => {
+								// generic error
+								extension.collector.warn(localize(
+									'badFile',
+									"The snippet file \"{0}\" could not be read.",
+									file.location.toString()
+								));
+							});
+						}
+
+					}
 				}
 			}
-		}
+		});
 	}
 
 	private _initWorkspaceSnippets(): void {

From cc31abab70a42a472de8f9415f55731e6f9fb094 Mon Sep 17 00:00:00 2001
From: Joao Moreno <joao.moreno@microsoft.com>
Date: Tue, 9 Oct 2018 16:12:44 +0200
Subject: [PATCH 57/76] fix keybindings editor

---
 src/vs/workbench/parts/preferences/browser/keybindingsEditor.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/workbench/parts/preferences/browser/keybindingsEditor.ts b/src/vs/workbench/parts/preferences/browser/keybindingsEditor.ts
index 65964459198..c794842b4fe 100644
--- a/src/vs/workbench/parts/preferences/browser/keybindingsEditor.ts
+++ b/src/vs/workbench/parts/preferences/browser/keybindingsEditor.ts
@@ -377,7 +377,7 @@ export class KeybindingsEditor extends BaseEditor implements IKeybindingsEditor
 		this.keybindingsListContainer = DOM.append(parent, $('.keybindings-list-container'));
 
 		this.keybindingsList = this._register(this.instantiationService.createInstance(WorkbenchList, this.keybindingsListContainer, new Delegate(), [new KeybindingHeaderRenderer(), new KeybindingItemRenderer(this, this.keybindingsService)],
-			{ identityProvider: e => e.id, mouseSupport: true, ariaLabel: localize('keybindingsLabel', "Keybindings") })) as WorkbenchList<IListEntry>;
+			{ identityProvider: e => e.id, mouseSupport: true, ariaLabel: localize('keybindingsLabel', "Keybindings"), setRowLineHeight: false })) as WorkbenchList<IListEntry>;
 		this._register(this.keybindingsList.onContextMenu(e => this.onContextMenu(e)));
 		this._register(this.keybindingsList.onFocusChange(e => this.onFocusChange(e)));
 		this._register(this.keybindingsList.onDidFocus(() => {

From 30eeffce9eb53708b7653e460b8b745444d84380 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 16:13:30 +0200
Subject: [PATCH 58/76] fix instantiation service using the wrong scope to
 create services

---
 .../instantiation/common/instantiationService.ts       | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/vs/platform/instantiation/common/instantiationService.ts b/src/vs/platform/instantiation/common/instantiationService.ts
index b17d224a964..acfcda04853 100644
--- a/src/vs/platform/instantiation/common/instantiationService.ts
+++ b/src/vs/platform/instantiation/common/instantiationService.ts
@@ -186,7 +186,7 @@ export class InstantiationService implements IInstantiationService {
 
 			for (let { data } of roots) {
 				// create instance and overwrite the service collections
-				const instance = this._createServiceInstance(data.desc.ctor, data.desc.staticArguments, data._trace);
+				const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data._trace);
 				this._setServiceInstance(data.id, instance);
 				graph.removeNode(data);
 			}
@@ -195,6 +195,14 @@ export class InstantiationService implements IInstantiationService {
 		return <T>this._getServiceInstanceOrDescriptor(id);
 	}
 
+	private _createServiceInstanceWithOwner<T>(id: ServiceIdentifier<T>, ctor: any, args: any[] = [], _trace: Trace): T {
+		if (this._services.get(id) instanceof SyncDescriptor) {
+			return this._createServiceInstance(ctor, args, _trace);
+		} else {
+			return this._parent._createServiceInstanceWithOwner(id, ctor, args, _trace);
+		}
+	}
+
 	protected _createServiceInstance<T>(ctor: any, args: any[] = [], _trace: Trace): T {
 		return this._createInstance(ctor, args, _trace);
 	}

From 17d36c47a9f8474b900cee03cae359de2d245aac Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 16:22:18 +0200
Subject: [PATCH 59/76] minor polish

---
 src/vs/workbench/parts/debug/common/debug.ts              | 1 -
 src/vs/workbench/parts/debug/common/debugModel.ts         | 1 +
 .../parts/debug/electron-browser/debug.contribution.ts    | 8 ++++----
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/vs/workbench/parts/debug/common/debug.ts b/src/vs/workbench/parts/debug/common/debug.ts
index 3ae4ba92f13..cf0e06d267c 100644
--- a/src/vs/workbench/parts/debug/common/debug.ts
+++ b/src/vs/workbench/parts/debug/common/debug.ts
@@ -41,7 +41,6 @@ export const CONTEXT_DEBUG_TYPE = new RawContextKey<string>('debugType', undefin
 export const CONTEXT_DEBUG_CONFIGURATION_TYPE = new RawContextKey<string>('debugConfigurationType', undefined);
 export const CONTEXT_DEBUG_STATE = new RawContextKey<string>('debugState', 'inactive');
 export const CONTEXT_IN_DEBUG_MODE = new RawContextKey<boolean>('inDebugMode', false);
-export const CONTEXT_NOT_IN_DEBUG_MODE = CONTEXT_IN_DEBUG_MODE.toNegated();
 export const CONTEXT_IN_DEBUG_REPL = new RawContextKey<boolean>('inDebugRepl', false);
 export const CONTEXT_BREAKPOINT_WIDGET_VISIBLE = new RawContextKey<boolean>('breakpointWidgetVisible', false);
 export const CONTEXT_IN_BREAKPOINT_WIDGET = new RawContextKey<boolean>('inBreakpointWidget', false);
diff --git a/src/vs/workbench/parts/debug/common/debugModel.ts b/src/vs/workbench/parts/debug/common/debugModel.ts
index fff0e7352d5..59c903072db 100644
--- a/src/vs/workbench/parts/debug/common/debugModel.ts
+++ b/src/vs/workbench/parts/debug/common/debugModel.ts
@@ -1049,6 +1049,7 @@ export class DebugModel implements IDebugModel {
 	}
 
 	public dispose(): void {
+		// Make sure to shutdown each session, such that no debugged process is left laying around
 		this.sessions.forEach(s => s.shutdown());
 		this.toDispose = lifecycle.dispose(this.toDispose);
 	}
diff --git a/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts b/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
index 4f3652fdb42..17fe3ee5589 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts
@@ -23,7 +23,7 @@ import { WatchExpressionsView } from 'vs/workbench/parts/debug/electron-browser/
 import { CallStackView } from 'vs/workbench/parts/debug/electron-browser/callStackView';
 import { Extensions as WorkbenchExtensions, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions';
 import {
-	IDebugService, VIEWLET_ID, REPL_ID, CONTEXT_NOT_IN_DEBUG_MODE, CONTEXT_IN_DEBUG_MODE, INTERNAL_CONSOLE_OPTIONS_SCHEMA,
+	IDebugService, VIEWLET_ID, REPL_ID, CONTEXT_IN_DEBUG_MODE, INTERNAL_CONSOLE_OPTIONS_SCHEMA,
 	CONTEXT_DEBUG_STATE, VARIABLES_VIEW_ID, CALLSTACK_VIEW_ID, WATCH_VIEW_ID, BREAKPOINTS_VIEW_ID, VIEW_CONTAINER, LOADED_SCRIPTS_VIEW_ID, CONTEXT_LOADED_SCRIPTS_SUPPORTED
 } from 'vs/workbench/parts/debug/common/debug';
 import { IPartService } from 'vs/workbench/services/part/common/partService';
@@ -130,7 +130,7 @@ Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).regi
 
 const debugCategory = nls.localize('debugCategory', "Debug");
 registry.registerWorkbenchAction(new SyncActionDescriptor(
-	StartAction, StartAction.ID, StartAction.LABEL, { primary: KeyCode.F5 }, CONTEXT_NOT_IN_DEBUG_MODE), 'Debug: Start Debugging', debugCategory);
+	StartAction, StartAction.ID, StartAction.LABEL, { primary: KeyCode.F5 }, CONTEXT_IN_DEBUG_MODE.toNegated()), 'Debug: Start Debugging', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepOverAction, StepOverAction.ID, StepOverAction.LABEL, { primary: KeyCode.F10 }, CONTEXT_IN_DEBUG_MODE), 'Debug: Step Over', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepIntoAction, StepIntoAction.ID, StepIntoAction.LABEL, { primary: KeyCode.F11 }, CONTEXT_IN_DEBUG_MODE, KeybindingWeight.WorkbenchContrib + 1), 'Debug: Step Into', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepOutAction, StepOutAction.ID, StepOutAction.LABEL, { primary: KeyMod.Shift | KeyCode.F11 }, CONTEXT_IN_DEBUG_MODE), 'Debug: Step Out', debugCategory);
@@ -143,7 +143,7 @@ registry.registerWorkbenchAction(new SyncActionDescriptor(TerminateThreadAction,
 registry.registerWorkbenchAction(new SyncActionDescriptor(ConfigureAction, ConfigureAction.ID, ConfigureAction.LABEL), 'Debug: Open launch.json', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(AddFunctionBreakpointAction, AddFunctionBreakpointAction.ID, AddFunctionBreakpointAction.LABEL), 'Debug: Add Function Breakpoint', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(ReapplyBreakpointsAction, ReapplyBreakpointsAction.ID, ReapplyBreakpointsAction.LABEL), 'Debug: Reapply All Breakpoints', debugCategory);
-registry.registerWorkbenchAction(new SyncActionDescriptor(RunAction, RunAction.ID, RunAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.F5, mac: { primary: KeyMod.WinCtrl | KeyCode.F5 } }, CONTEXT_NOT_IN_DEBUG_MODE), 'Debug: Start Without Debugging', debugCategory);
+registry.registerWorkbenchAction(new SyncActionDescriptor(RunAction, RunAction.ID, RunAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.F5, mac: { primary: KeyMod.WinCtrl | KeyCode.F5 } }, CONTEXT_IN_DEBUG_MODE.toNegated()), 'Debug: Start Without Debugging', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(RemoveAllBreakpointsAction, RemoveAllBreakpointsAction.ID, RemoveAllBreakpointsAction.LABEL), 'Debug: Remove All Breakpoints', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(EnableAllBreakpointsAction, EnableAllBreakpointsAction.ID, EnableAllBreakpointsAction.LABEL), 'Debug: Enable All Breakpoints', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(DisableAllBreakpointsAction, DisableAllBreakpointsAction.ID, DisableAllBreakpointsAction.LABEL), 'Debug: Disable All Breakpoints', debugCategory);
@@ -449,7 +449,7 @@ if (isMacintosh) {
 		});
 	};
 
-	registerTouchBarEntry(StartAction.ID, StartAction.LABEL, 0, CONTEXT_NOT_IN_DEBUG_MODE, 'continue-tb.png');
+	registerTouchBarEntry(StartAction.ID, StartAction.LABEL, 0, CONTEXT_IN_DEBUG_MODE.toNegated(), 'continue-tb.png');
 	registerTouchBarEntry(ContinueAction.ID, ContinueAction.LABEL, 0, CONTEXT_DEBUG_STATE.isEqualTo('stopped'), 'continue-tb.png');
 	registerTouchBarEntry(PauseAction.ID, PauseAction.LABEL, 1, ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ContextKeyExpr.notEquals('debugState', 'stopped')), 'pause-tb.png');
 	registerTouchBarEntry(StepOverAction.ID, StepOverAction.LABEL, 2, CONTEXT_DEBUG_STATE.isEqualTo('stopped'), 'stepover-tb.png');

From 8bd5387d3771bfc5a99ab02873582dfa4a633db8 Mon Sep 17 00:00:00 2001
From: Rob Lourens <roblourens@gmail.com>
Date: Mon, 8 Oct 2018 17:50:43 -0700
Subject: [PATCH 60/76] Implement multiline search for #13155

---
 src/vs/base/common/strings.ts                 | 18 +++++-
 src/vs/base/test/common/strings.test.ts       | 12 ++++
 src/vs/editor/common/model/textModelSearch.ts | 58 +++++++++----------
 .../test/common/model/textModelSearch.test.ts | 15 ++++-
 src/vs/platform/search/common/search.ts       | 33 +++++++----
 .../search/test/common/search.test.ts         | 26 ++++++++-
 .../parts/search/common/queryBuilder.ts       | 26 +++++++--
 .../parts/search/common/searchModel.ts        | 12 +---
 .../services/search/node/ripgrepTextSearch.ts | 27 ++++++---
 .../services/search/node/searchService.ts     | 12 +---
 10 files changed, 161 insertions(+), 78 deletions(-)

diff --git a/src/vs/base/common/strings.ts b/src/vs/base/common/strings.ts
index a2504791f3d..40f273531a6 100644
--- a/src/vs/base/common/strings.ts
+++ b/src/vs/base/common/strings.ts
@@ -686,4 +686,20 @@ export function containsUppercaseCharacter(target: string, ignoreEscapedChars =
 
 export function uppercaseFirstLetter(str: string): string {
 	return str.charAt(0).toUpperCase() + str.slice(1);
-}
\ No newline at end of file
+}
+
+export function getNLines(str: string, n = 1): string {
+	if (n === 0) {
+		return '';
+	}
+
+	let idx = -1;
+	do {
+		idx = str.indexOf('\n', idx + 1);
+		n--;
+	} while (n > 0 && idx >= 0);
+
+	return idx >= 0 ?
+		str.substr(0, idx) :
+		str;
+}
diff --git a/src/vs/base/test/common/strings.test.ts b/src/vs/base/test/common/strings.test.ts
index 88179c27bc1..2e8ee07797b 100644
--- a/src/vs/base/test/common/strings.test.ts
+++ b/src/vs/base/test/common/strings.test.ts
@@ -391,4 +391,16 @@ suite('Strings', () => {
 			assert.equal(strings.uppercaseFirstLetter(inStr), result, `Wrong result for ${inStr}`);
 		});
 	});
+
+	test('getNLines', () => {
+		assert.equal(strings.getNLines('', 5), '');
+		assert.equal(strings.getNLines('foo', 5), 'foo');
+		assert.equal(strings.getNLines('foo\nbar', 5), 'foo\nbar');
+		assert.equal(strings.getNLines('foo\nbar', 2), 'foo\nbar');
+
+		assert.equal(strings.getNLines('foo\nbar', 1), 'foo');
+		assert.equal(strings.getNLines('foo\nbar'), 'foo');
+		assert.equal(strings.getNLines('foo\nbar\nsomething', 2), 'foo\nbar');
+		assert.equal(strings.getNLines('foo', 0), '');
+	});
 });
diff --git a/src/vs/editor/common/model/textModelSearch.ts b/src/vs/editor/common/model/textModelSearch.ts
index 138c813fefc..c75b008b120 100644
--- a/src/vs/editor/common/model/textModelSearch.ts
+++ b/src/vs/editor/common/model/textModelSearch.ts
@@ -26,34 +26,6 @@ export class SearchParams {
 		this.wordSeparators = wordSeparators;
 	}
 
-	private static _isMultilineRegexSource(searchString: string): boolean {
-		if (!searchString || searchString.length === 0) {
-			return false;
-		}
-
-		for (let i = 0, len = searchString.length; i < len; i++) {
-			const chCode = searchString.charCodeAt(i);
-
-			if (chCode === CharCode.Backslash) {
-
-				// move to next char
-				i++;
-
-				if (i >= len) {
-					// string ends with a \
-					break;
-				}
-
-				const nextChCode = searchString.charCodeAt(i);
-				if (nextChCode === CharCode.n || nextChCode === CharCode.r || nextChCode === CharCode.W) {
-					return true;
-				}
-			}
-		}
-
-		return false;
-	}
-
 	public parseSearchRequest(): SearchData {
 		if (this.searchString === '') {
 			return null;
@@ -62,7 +34,7 @@ export class SearchParams {
 		// Try to create a RegExp out of the params
 		let multiline: boolean;
 		if (this.isRegex) {
-			multiline = SearchParams._isMultilineRegexSource(this.searchString);
+			multiline = isMultilineRegexSource(this.searchString);
 		} else {
 			multiline = (this.searchString.indexOf('\n') >= 0);
 		}
@@ -93,6 +65,34 @@ export class SearchParams {
 	}
 }
 
+export function isMultilineRegexSource(searchString: string): boolean {
+	if (!searchString || searchString.length === 0) {
+		return false;
+	}
+
+	for (let i = 0, len = searchString.length; i < len; i++) {
+		const chCode = searchString.charCodeAt(i);
+
+		if (chCode === CharCode.Backslash) {
+
+			// move to next char
+			i++;
+
+			if (i >= len) {
+				// string ends with a \
+				break;
+			}
+
+			const nextChCode = searchString.charCodeAt(i);
+			if (nextChCode === CharCode.n || nextChCode === CharCode.r || nextChCode === CharCode.W) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
 export class SearchData {
 
 	/**
diff --git a/src/vs/editor/test/common/model/textModelSearch.test.ts b/src/vs/editor/test/common/model/textModelSearch.test.ts
index 54c98e67f8d..3c9ced8ebd1 100644
--- a/src/vs/editor/test/common/model/textModelSearch.test.ts
+++ b/src/vs/editor/test/common/model/textModelSearch.test.ts
@@ -7,7 +7,7 @@ import { Position } from 'vs/editor/common/core/position';
 import { FindMatch, EndOfLineSequence } from 'vs/editor/common/model';
 import { Range } from 'vs/editor/common/core/range';
 import { TextModel } from 'vs/editor/common/model/textModel';
-import { TextModelSearch, SearchParams, SearchData } from 'vs/editor/common/model/textModelSearch';
+import { TextModelSearch, SearchParams, SearchData, isMultilineRegexSource } from 'vs/editor/common/model/textModelSearch';
 import { getMapForWordSeparators } from 'vs/editor/common/controller/wordCharacterClassifier';
 import { USUAL_WORD_SEPARATORS } from 'vs/editor/common/model/wordHelper';
 
@@ -720,4 +720,17 @@ suite('TextModelSearch', () => {
 			]
 		);
 	});
+
+	test('isMultilineRegexSource', () => {
+		assert(!isMultilineRegexSource('foo'));
+		assert(!isMultilineRegexSource(''));
+		assert(!isMultilineRegexSource('foo\\sbar'));
+		assert(!isMultilineRegexSource('\\\\notnewline'));
+
+		assert(isMultilineRegexSource('foo\\nbar'));
+		assert(isMultilineRegexSource('foo\\nbar\\s'));
+		assert(isMultilineRegexSource('foo\\r\\n'));
+		assert(isMultilineRegexSource('\\n'));
+		assert(isMultilineRegexSource('foo\\W'));
+	});
 });
diff --git a/src/vs/platform/search/common/search.ts b/src/vs/platform/search/common/search.ts
index 31be8e8fcde..1f41b01885d 100644
--- a/src/vs/platform/search/common/search.ts
+++ b/src/vs/platform/search/common/search.ts
@@ -13,6 +13,7 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { IFilesConfiguration } from 'vs/platform/files/common/files';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { getNLines } from 'vs/base/common/strings';
 
 export const VIEW_ID = 'workbench.view.search';
 
@@ -235,41 +236,53 @@ export class TextSearchResult implements ITextSearchResult {
 	range: ISearchRange;
 	preview: ITextSearchResultPreview;
 
-	constructor(fullLine: string, range: ISearchRange, previewOptions?: ITextSearchPreviewOptions) {
+	constructor(text: string, range: ISearchRange, previewOptions?: ITextSearchPreviewOptions) {
 		this.range = range;
 		if (previewOptions) {
+			text = getNLines(text, previewOptions.matchLines);
 			const leadingChars = Math.floor(previewOptions.charsPerLine / 5);
+			const endColumnByTrimmedLines = (range.startLineNumber + previewOptions.matchLines - 1) === range.endLineNumber ? // if single line...
+				range.endColumn :
+				previewOptions.charsPerLine;
+
+			// This doesn't handle all previewOptions correctly
 			const previewStart = Math.max(range.startColumn - leadingChars, 0);
-			const previewEnd = previewOptions.charsPerLine + previewStart;
-			const endOfMatchRangeInPreview = Math.min(previewEnd, range.endColumn - previewStart);
+			const endByCharsPerLine = previewOptions.charsPerLine + previewStart;
+			const trimmedEndOfMatchRangeInPreview = Math.min(endByCharsPerLine, endColumnByTrimmedLines - previewStart);
 
 			this.preview = {
-				text: fullLine.substring(previewStart, previewEnd),
-				match: new OneLineRange(0, range.startColumn - previewStart, endOfMatchRangeInPreview)
+				text: text.substring(previewStart, endByCharsPerLine),
+				match: new OneLineRange(0, range.startColumn - previewStart, trimmedEndOfMatchRangeInPreview)
 			};
 		} else {
 			this.preview = {
-				text: fullLine,
+				text: text,
 				match: new OneLineRange(0, range.startColumn, range.endColumn)
 			};
 		}
 	}
 }
 
-export class OneLineRange implements ISearchRange {
+export class SearchRange implements ISearchRange {
 	startLineNumber: number;
 	startColumn: number;
 	endLineNumber: number;
 	endColumn: number;
 
-	constructor(lineNumber: number, startColumn: number, endColumn: number) {
-		this.startLineNumber = lineNumber;
+	constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number) {
+		this.startLineNumber = startLineNumber;
 		this.startColumn = startColumn;
-		this.endLineNumber = lineNumber;
+		this.endLineNumber = endLineNumber;
 		this.endColumn = endColumn;
 	}
 }
 
+export class OneLineRange extends SearchRange {
+	constructor(lineNumber: number, startColumn: number, endColumn: number) {
+		super(lineNumber, startColumn, lineNumber, endColumn);
+	}
+}
+
 export interface ISearchConfigurationProperties {
 	exclude: glob.IExpression;
 	useRipgrep: boolean;
diff --git a/src/vs/platform/search/test/common/search.test.ts b/src/vs/platform/search/test/common/search.test.ts
index b6c8f965766..25b89a956d7 100644
--- a/src/vs/platform/search/test/common/search.test.ts
+++ b/src/vs/platform/search/test/common/search.test.ts
@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as assert from 'assert';
-import { ITextSearchPreviewOptions, OneLineRange, TextSearchResult } from 'vs/platform/search/common/search';
+import { ITextSearchPreviewOptions, OneLineRange, TextSearchResult, SearchRange } from 'vs/platform/search/common/search';
 
 suite('TextSearchResult', () => {
 
@@ -78,4 +78,28 @@ suite('TextSearchResult', () => {
 		assert.deepEqual(result.range, range);
 		assertPreviewRangeText('b', result);
 	});
+
+	test('one line of multiline match', () => {
+		const previewOptions: ITextSearchPreviewOptions = {
+			matchLines: 1,
+			charsPerLine: 10000
+		};
+
+		const range = new SearchRange(5, 4, 6, 3);
+		const result = new TextSearchResult('foo bar\nfoo bar', range, previewOptions);
+		assert.deepEqual(result.range, range);
+		assertPreviewRangeText('bar', result);
+	});
+
+	// test('all lines of multiline match', () => {
+	// 	const previewOptions: ITextSearchPreviewOptions = {
+	// 		matchLines: 5,
+	// 		charsPerLine: 10000
+	// 	};
+
+	// 	const range = new SearchRange(5, 4, 6, 3);
+	// 	const result = new TextSearchResult('foo bar\nfoo bar', range, previewOptions);
+	// 	assert.deepEqual(result.range, range);
+	// 	assertPreviewRangeText('bar\nfoo', result);
+	// });
 });
\ No newline at end of file
diff --git a/src/vs/workbench/parts/search/common/queryBuilder.ts b/src/vs/workbench/parts/search/common/queryBuilder.ts
index 29d15051342..370b0d4cb72 100644
--- a/src/vs/workbench/parts/search/common/queryBuilder.ts
+++ b/src/vs/workbench/parts/search/common/queryBuilder.ts
@@ -17,6 +17,7 @@ import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/
 import { IPatternInfo, IQueryOptions, IFolderQuery, ISearchQuery, QueryType, ISearchConfiguration, getExcludes, pathIncludedInQuery } from 'vs/platform/search/common/search';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { isMultilineRegexSource } from 'vs/editor/common/model/textModelSearch';
 
 export interface ISearchPathPattern {
 	searchPath: uri;
@@ -77,7 +78,8 @@ export class QueryBuilder {
 		const ignoreSymlinks = !this.configurationService.getValue<ISearchConfiguration>().search.followSymlinks;
 
 		if (contentPattern) {
-			this.resolveSmartCaseToCaseSensitive(contentPattern);
+			contentPattern.isCaseSensitive = this.isCaseSensitive(contentPattern);
+			contentPattern.isMultiline = this.isMultiline(contentPattern);
 
 			contentPattern.wordSeparators = this.configurationService.getValue<ISearchConfiguration>().editor.wordSeparators;
 		}
@@ -113,19 +115,33 @@ export class QueryBuilder {
 	}
 
 	/**
-	 * Fix the isCaseSensitive flag based on the query and the isSmartCase flag, for search providers that don't support smart case natively.
+	 * Resolve isCaseSensitive flag based on the query and the isSmartCase flag, for search providers that don't support smart case natively.
 	 */
-	private resolveSmartCaseToCaseSensitive(contentPattern: IPatternInfo): void {
+	private isCaseSensitive(contentPattern: IPatternInfo): boolean {
 		if (contentPattern.isSmartCase) {
 			if (contentPattern.isRegExp) {
 				// Consider it case sensitive if it contains an unescaped capital letter
 				if (strings.containsUppercaseCharacter(contentPattern.pattern, true)) {
-					contentPattern.isCaseSensitive = true;
+					return true;
 				}
 			} else if (strings.containsUppercaseCharacter(contentPattern.pattern)) {
-				contentPattern.isCaseSensitive = true;
+				return true;
 			}
 		}
+
+		return contentPattern.isCaseSensitive;
+	}
+
+	private isMultiline(contentPattern: IPatternInfo): boolean {
+		if (contentPattern.isMultiline) {
+			return true;
+		}
+
+		if (contentPattern.isRegExp && isMultilineRegexSource(contentPattern.pattern)) {
+			return true;
+		}
+
+		return false;
 	}
 
 	/**
diff --git a/src/vs/workbench/parts/search/common/searchModel.ts b/src/vs/workbench/parts/search/common/searchModel.ts
index d76f8aa6d70..bcac923dd60 100644
--- a/src/vs/workbench/parts/search/common/searchModel.ts
+++ b/src/vs/workbench/parts/search/common/searchModel.ts
@@ -992,19 +992,9 @@ export class RangeHighlightDecorations implements IDisposable {
 	});
 }
 
-/**
- * While search doesn't support multiline matches, collapse editor matches to a single line
- */
 export function editorMatchToTextSearchResult(match: FindMatch, model: ITextModel, previewOptions: ITextSearchPreviewOptions): TextSearchResult {
-	let endLineNumber = match.range.endLineNumber - 1;
-	let endCol = match.range.endColumn - 1;
-	if (match.range.endLineNumber !== match.range.startLineNumber) {
-		endLineNumber = match.range.startLineNumber - 1;
-		endCol = model.getLineLength(match.range.startLineNumber);
-	}
-
 	return new TextSearchResult(
 		model.getLineContent(match.range.startLineNumber),
-		new Range(match.range.startLineNumber - 1, match.range.startColumn - 1, endLineNumber, endCol),
+		new Range(match.range.startLineNumber - 1, match.range.startColumn - 1, match.range.endLineNumber - 1, match.range.endColumn - 1),
 		previewOptions);
 }
diff --git a/src/vs/workbench/services/search/node/ripgrepTextSearch.ts b/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
index b81525496f0..7f394acb393 100644
--- a/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
+++ b/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
@@ -285,19 +285,24 @@ export class RipgrepParser extends EventEmitter {
 
 	private submatchToResult(parsedLine: any, match: any, uri: URI): TextSearchResult {
 		const lineNumber = parsedLine.data.line_number - 1;
-		let matchText = bytesOrTextToString(parsedLine.data.lines);
-		let start = match.start;
-		let end = match.end;
+		let lineText = bytesOrTextToString(parsedLine.data.lines);
+		let matchText = bytesOrTextToString(match.match);
+		const newlineMatches = matchText.match(/\n/g);
+		const newlines = newlineMatches ? newlineMatches.length : 0;
+		let startCol = match.start;
+		const endLineNumber = lineNumber + newlines;
+		let endCol = match.end - (lineText.lastIndexOf('\n', lineText.length - 2) + 1);
+
 		if (lineNumber === 0) {
-			if (strings.startsWithUTF8BOM(matchText)) {
-				matchText = strings.stripUTF8BOM(matchText);
-				start -= 3;
-				end -= 3;
+			if (strings.startsWithUTF8BOM(lineText)) {
+				lineText = strings.stripUTF8BOM(lineText);
+				startCol -= 3;
+				endCol -= 3;
 			}
 		}
 
-		const range = new Range(lineNumber, start, lineNumber, end);
-		return new TextSearchResult(matchText, range, this.previewOptions);
+		const range = new Range(lineNumber, startCol, endLineNumber, endCol);
+		return new TextSearchResult(lineText, range, this.previewOptions);
 	}
 
 	private getFileMatch(relativeOrAbsolutePath: string): FileMatch {
@@ -490,6 +495,10 @@ function getRgArgs(config: IRawSearch) {
 
 	args.push('--json');
 
+	if (config.contentPattern.isMultiline) {
+		args.push('--multiline');
+	}
+
 	// Folder to search
 	args.push('--');
 
diff --git a/src/vs/workbench/services/search/node/searchService.ts b/src/vs/workbench/services/search/node/searchService.ts
index db20b4bbef1..498f266d123 100644
--- a/src/vs/workbench/services/search/node/searchService.ts
+++ b/src/vs/workbench/services/search/node/searchService.ts
@@ -589,19 +589,9 @@ export class DiskSearch implements ISearchResultProvider {
 	}
 }
 
-/**
- * While search doesn't support multiline matches, collapse editor matches to a single line
- */
 function editorMatchToTextSearchResult(match: FindMatch, model: ITextModel, previewOptions: ITextSearchPreviewOptions): TextSearchResult {
-	let endLineNumber = match.range.endLineNumber - 1;
-	let endCol = match.range.endColumn - 1;
-	if (match.range.endLineNumber !== match.range.startLineNumber) {
-		endLineNumber = match.range.startLineNumber - 1;
-		endCol = model.getLineLength(match.range.startLineNumber);
-	}
-
 	return new TextSearchResult(
 		model.getLineContent(match.range.startLineNumber),
-		new Range(match.range.startLineNumber - 1, match.range.startColumn - 1, endLineNumber, endCol),
+		new Range(match.range.startLineNumber - 1, match.range.startColumn - 1, match.range.endLineNumber - 1, match.range.endColumn - 1),
 		previewOptions);
 }

From 9c9e3164382186e57951e216f67d0baac881da31 Mon Sep 17 00:00:00 2001
From: Joao Moreno <joao.moreno@microsoft.com>
Date: Tue, 9 Oct 2018 17:05:50 +0200
Subject: [PATCH 61/76] fixes #60018

---
 src/vs/base/browser/ui/splitview/panelview.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/base/browser/ui/splitview/panelview.ts b/src/vs/base/browser/ui/splitview/panelview.ts
index 2f7554426dc..3d0da96fb2d 100644
--- a/src/vs/base/browser/ui/splitview/panelview.ts
+++ b/src/vs/base/browser/ui/splitview/panelview.ts
@@ -188,9 +188,9 @@ export abstract class Panel implements IView {
 
 	layout(size: number): void {
 		const headerSize = this.headerVisible ? Panel.HEADER_SIZE : 0;
-		this.layoutBody(size - headerSize);
 
 		if (this.isExpanded()) {
+			this.layoutBody(size - headerSize);
 			this.expandedSize = size;
 		}
 	}

From f9281d8317691cb970387fbe8c9846e1393ef1e3 Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 17:05:32 +0200
Subject: [PATCH 62/76] debug: simplify setting breakpoint session data

---
 .../parts/debug/browser/debugActions.ts       |  1 -
 src/vs/workbench/parts/debug/common/debug.ts  |  6 ++----
 .../debug/electron-browser/debugService.ts    | 16 ++++----------
 .../debug/electron-browser/debugSession.ts    | 21 +++++++++----------
 .../parts/debug/test/common/mockDebug.ts      |  6 +++---
 5 files changed, 19 insertions(+), 31 deletions(-)

diff --git a/src/vs/workbench/parts/debug/browser/debugActions.ts b/src/vs/workbench/parts/debug/browser/debugActions.ts
index 31df8070f8a..ab260b09869 100644
--- a/src/vs/workbench/parts/debug/browser/debugActions.ts
+++ b/src/vs/workbench/parts/debug/browser/debugActions.ts
@@ -196,7 +196,6 @@ export class SelectAndStartAction extends AbstractDebugAction {
 		@IQuickOpenService private quickOpenService: IQuickOpenService
 	) {
 		super(id, label, undefined, debugService, keybindingService);
-		this.quickOpenService = quickOpenService;
 	}
 
 	public run(): TPromise<any> {
diff --git a/src/vs/workbench/parts/debug/common/debug.ts b/src/vs/workbench/parts/debug/common/debug.ts
index cf0e06d267c..937ae541a8c 100644
--- a/src/vs/workbench/parts/debug/common/debug.ts
+++ b/src/vs/workbench/parts/debug/common/debug.ts
@@ -116,8 +116,6 @@ export interface IDebugger {
 	getCustomTelemetryService(): TPromise<TelemetryService>;
 }
 
-export type ActualBreakpoints = { [id: string]: DebugProtocol.Breakpoint };
-
 export enum State {
 	Inactive,
 	Initializing,
@@ -186,8 +184,8 @@ export interface IDebugSession extends ITreeElement {
 	terminate(restart?: boolean /* false */): TPromise<void>;
 	disconnect(restart?: boolean /* false */): TPromise<void>;
 
-	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints | undefined>;
-	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints | undefined>;
+	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<void>;
+	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<void>;
 	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void>;
 
 	stackTrace(threadId: number, startFrame: number, levels: number): TPromise<DebugProtocol.StackTraceResponse>;
diff --git a/src/vs/workbench/parts/debug/electron-browser/debugService.ts b/src/vs/workbench/parts/debug/electron-browser/debugService.ts
index 3f3a6f89294..261e366b312 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debugService.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debugService.ts
@@ -871,13 +871,9 @@ export class DebugService implements IDebugService {
 
 		const breakpointsToSend = this.model.getBreakpoints({ uri: modelUri, enabledOnly: true });
 
-		return this.sendToOneOrAllSessions(session, s => {
-			return s.sendBreakpoints(modelUri, breakpointsToSend, sourceModified).then(data => {
-				if (data) {
-					this.model.setBreakpointSessionData(s.getId(), data);
-				}
-			});
-		});
+		return this.sendToOneOrAllSessions(session, s =>
+			s.sendBreakpoints(modelUri, breakpointsToSend, sourceModified)
+		);
 	}
 
 	private sendFunctionBreakpoints(session?: IDebugSession): TPromise<void> {
@@ -885,11 +881,7 @@ export class DebugService implements IDebugService {
 		const breakpointsToSend = this.model.getFunctionBreakpoints().filter(fbp => fbp.enabled && this.model.areBreakpointsActivated());
 
 		return this.sendToOneOrAllSessions(session, s => {
-			return s.capabilities.supportsFunctionBreakpoints ? s.sendFunctionBreakpoints(breakpointsToSend).then(data => {
-				if (data) {
-					this.model.setBreakpointSessionData(s.getId(), data);
-				}
-			}) : Promise.resolve(undefined);
+			return s.capabilities.supportsFunctionBreakpoints ? s.sendFunctionBreakpoints(breakpointsToSend) : Promise.resolve(undefined);
 		});
 	}
 
diff --git a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
index 096260921cc..7e160b0ee7f 100644
--- a/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
+++ b/src/vs/workbench/parts/debug/electron-browser/debugSession.ts
@@ -13,7 +13,7 @@ import { Event, Emitter } from 'vs/base/common/event';
 import { CompletionItem, completionKindFromLegacyString } from 'vs/editor/common/modes';
 import { Position } from 'vs/editor/common/core/position';
 import * as aria from 'vs/base/browser/ui/aria/aria';
-import { IDebugSession, IConfig, IThread, IRawModelUpdate, IDebugService, IRawStoppedDetails, State, LoadedSourceEvent, IFunctionBreakpoint, IExceptionBreakpoint, ActualBreakpoints, IBreakpoint, IExceptionInfo, AdapterEndEvent, IDebugger, VIEWLET_ID, IDebugConfiguration, IReplElement, IStackFrame, IExpression, IReplElementSource } from 'vs/workbench/parts/debug/common/debug';
+import { IDebugSession, IConfig, IThread, IRawModelUpdate, IDebugService, IRawStoppedDetails, State, LoadedSourceEvent, IFunctionBreakpoint, IExceptionBreakpoint, IBreakpoint, IExceptionInfo, AdapterEndEvent, IDebugger, VIEWLET_ID, IDebugConfiguration, IReplElement, IStackFrame, IExpression, IReplElementSource } from 'vs/workbench/parts/debug/common/debug';
 import { Source } from 'vs/workbench/parts/debug/common/debugSource';
 import { mixin } from 'vs/base/common/objects';
 import { Thread, ExpressionContainer, DebugModel } from 'vs/workbench/parts/debug/common/debugModel';
@@ -230,7 +230,7 @@ export class DebugSession implements IDebugSession {
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	sendBreakpoints(modelUri: URI, breakpointsToSend: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints | undefined> {
+	sendBreakpoints(modelUri: URI, breakpointsToSend: IBreakpoint[], sourceModified: boolean): TPromise<void> {
 
 		if (!this.raw) {
 			return Promise.reject(new Error('no debug adapter'));
@@ -261,35 +261,34 @@ export class DebugSession implements IDebugSession {
 			breakpoints: breakpointsToSend.map(bp => ({ line: bp.lineNumber, column: bp.column, condition: bp.condition, hitCondition: bp.hitCondition, logMessage: bp.logMessage })),
 			sourceModified
 		}).then(response => {
-
 			if (response && response.body) {
-				const data: ActualBreakpoints = Object.create(null);
+				const data: { [id: string]: DebugProtocol.Breakpoint } = Object.create(null);
 				for (let i = 0; i < breakpointsToSend.length; i++) {
 					data[breakpointsToSend[i].getId()] = response.body.breakpoints[i];
 				}
+
 				this.model.setBreakpointSessionData(this.getId(), data);
-				return data;
 			}
-			return undefined;
 		});
 	}
 
-	sendFunctionBreakpoints(fbpts: IFunctionBreakpoint[]): TPromise<ActualBreakpoints | undefined> {
+	sendFunctionBreakpoints(fbpts: IFunctionBreakpoint[]): TPromise<void> {
 		if (this.raw) {
 			if (this.raw.readyForBreakpoints) {
 				return this.raw.setFunctionBreakpoints({ breakpoints: fbpts }).then(response => {
 					if (response && response.body) {
-						const data: ActualBreakpoints = Object.create(null);
+						const data: { [id: string]: DebugProtocol.Breakpoint } = Object.create(null);
 						for (let i = 0; i < fbpts.length; i++) {
 							data[fbpts[i].getId()] = response.body.breakpoints[i];
 						}
-						return data;
+						this.model.setBreakpointSessionData(this.getId(), data);
 					}
-					return undefined;
 				});
 			}
-			return Promise.resolve(undefined);
+
+			return TPromise.as(undefined);
 		}
+
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
diff --git a/src/vs/workbench/parts/debug/test/common/mockDebug.ts b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
index 6bffd5e09fa..fdab674b3b7 100644
--- a/src/vs/workbench/parts/debug/test/common/mockDebug.ts
+++ b/src/vs/workbench/parts/debug/test/common/mockDebug.ts
@@ -8,7 +8,7 @@ import { Event } from 'vs/base/common/event';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { Position } from 'vs/editor/common/core/position';
-import { ILaunch, IDebugService, State, IDebugSession, IConfigurationManager, IStackFrame, IBreakpointData, IBreakpointUpdateData, IConfig, IDebugModel, IViewModel, IBreakpoint, LoadedSourceEvent, IThread, IRawModelUpdate, ActualBreakpoints, IFunctionBreakpoint, IExceptionBreakpoint, IDebugger, IExceptionInfo, AdapterEndEvent, IReplElement, IExpression, IReplElementSource } from 'vs/workbench/parts/debug/common/debug';
+import { ILaunch, IDebugService, State, IDebugSession, IConfigurationManager, IStackFrame, IBreakpointData, IBreakpointUpdateData, IConfig, IDebugModel, IViewModel, IBreakpoint, LoadedSourceEvent, IThread, IRawModelUpdate, IFunctionBreakpoint, IExceptionBreakpoint, IDebugger, IExceptionInfo, AdapterEndEvent, IReplElement, IExpression, IReplElementSource } from 'vs/workbench/parts/debug/common/debug';
 import { Source } from 'vs/workbench/parts/debug/common/debugSource';
 import { CompletionItem } from 'vs/editor/common/modes';
 import Severity from 'vs/base/common/severity';
@@ -209,10 +209,10 @@ export class MockSession implements IDebugSession {
 	restart(): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints> {
+	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints> {
+	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void> {

From 53e166f7960da45dba3164118f71c0c6283b6d95 Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 17:20:04 +0200
Subject: [PATCH 63/76] perf - prevent layout trashing when remove/hiding parts
 splash

---
 .../parts/splash/electron-browser/partsSplash.contribution.ts   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/vs/workbench/parts/splash/electron-browser/partsSplash.contribution.ts b/src/vs/workbench/parts/splash/electron-browser/partsSplash.contribution.ts
index db1e63231d0..d3b1c0cbaed 100644
--- a/src/vs/workbench/parts/splash/electron-browser/partsSplash.contribution.ts
+++ b/src/vs/workbench/parts/splash/electron-browser/partsSplash.contribution.ts
@@ -98,7 +98,7 @@ class PartsSplash {
 	private _removePartsSplash(): void {
 		let element = document.getElementById(PartsSplash._splashElementId);
 		if (element) {
-			element.remove();
+			element.style.display = 'none';
 		}
 		// remove initial colors
 		let defaultStyles = document.head.getElementsByClassName('initialShellColors');

From 9ac1a920081ef247f14d275cad010ac7cfc47cdd Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 17:42:17 +0200
Subject: [PATCH 64/76] remove layout trasher which seems unnecessary, #60031

---
 src/vs/workbench/browser/layout.ts | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/vs/workbench/browser/layout.ts b/src/vs/workbench/browser/layout.ts
index 967c730dd71..94f2d97ac89 100644
--- a/src/vs/workbench/browser/layout.ts
+++ b/src/vs/workbench/browser/layout.ts
@@ -544,15 +544,6 @@ export class WorkbenchLayout extends Disposable implements IVerticalSashLayoutPr
 		position(this.workbenchContainer, 0, 0, 0, 0, 'relative');
 		size(this.workbenchContainer, this.workbenchSize.width, this.workbenchSize.height);
 
-		// Bug on Chrome: Sometimes Chrome wants to scroll the workbench container on layout changes. The fix is to reset scrolling in this case.
-		const workbenchContainer = this.workbenchContainer;
-		if (workbenchContainer.scrollTop > 0) {
-			workbenchContainer.scrollTop = 0;
-		}
-		if (workbenchContainer.scrollLeft > 0) {
-			workbenchContainer.scrollLeft = 0;
-		}
-
 		// Title Part
 		const titleContainer = this.parts.titlebar.getContainer();
 		if (isTitlebarHidden) {

From 40371ab59d3f9ce10facfbc2f5cbd2637ba30246 Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Tue, 9 Oct 2018 08:51:24 -0700
Subject: [PATCH 65/76] vscode-xterm@3.9.0-beta3

Fixes #60291
---
 package.json | 2 +-
 yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package.json b/package.json
index ae860ddb5c1..bb9cb6ae938 100644
--- a/package.json
+++ b/package.json
@@ -49,7 +49,7 @@
     "vscode-nsfw": "1.0.17",
     "vscode-ripgrep": "^1.2.2",
     "vscode-textmate": "^4.0.1",
-    "vscode-xterm": "3.9.0-beta2",
+    "vscode-xterm": "3.9.0-beta3",
     "winreg": "^1.2.4",
     "yauzl": "^2.9.1",
     "yazl": "^2.4.3"
diff --git a/yarn.lock b/yarn.lock
index 757d51dd7af..0f8b03139fc 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9351,10 +9351,10 @@ vscode-textmate@^4.0.1:
   dependencies:
     oniguruma "^7.0.0"
 
-vscode-xterm@3.9.0-beta2:
-  version "3.9.0-beta2"
-  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta2.tgz#36e6c6b3dee9324343d240acec0bc0af5283e8bd"
-  integrity sha512-v8uPv0UGoOxz6t22l/0uxIdcZVNOldk/5ZNp1zjVW+EBecE/zN4JCY3rAJALpgsTm4XlJZfi0f49yLVeyg3WeA==
+vscode-xterm@3.9.0-beta3:
+  version "3.9.0-beta3"
+  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta3.tgz#2a76fb9320971c17a0d4c2a5fe53e34692dff45d"
+  integrity sha512-CZpzmqSonz3f57XCaXE07m6lVvbkXlLq+knlDyYTmxBTrlIloY3Oe/YJszDfusJnq0F+xc8NAyuG3xisg6x7yw==
 
 vso-node-api@6.1.2-preview:
   version "6.1.2-preview"

From a7db2fbb3c55cca8b3d26b832f4fe44ff62caf7b Mon Sep 17 00:00:00 2001
From: isidor <inikolic@microsoft.com>
Date: Tue, 9 Oct 2018 17:59:56 +0200
Subject: [PATCH 66/76] fix build errors

---
 src/vs/workbench/browser/parts/panel/panelActions.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/vs/workbench/browser/parts/panel/panelActions.ts b/src/vs/workbench/browser/parts/panel/panelActions.ts
index 8adb4ef55d7..7433c1b1560 100644
--- a/src/vs/workbench/browser/parts/panel/panelActions.ts
+++ b/src/vs/workbench/browser/parts/panel/panelActions.ts
@@ -189,11 +189,11 @@ export class SwitchPanelViewAction extends Action {
 		super(id, name);
 	}
 
-	run(offset: number): TPromise<any> {
+	run(offset: number): Thenable<any> {
 		const pinnedPanels = this.panelService.getPinnedPanels();
 		const activePanel = this.panelService.getActivePanel();
 		if (!activePanel) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}
 		let targetPanelId: string;
 		for (let i = 0; i < pinnedPanels.length; i++) {
@@ -219,7 +219,7 @@ export class PreviousPanelViewAction extends SwitchPanelViewAction {
 		super(id, name, panelService);
 	}
 
-	run(): TPromise<any> {
+	run(): Thenable<any> {
 		return super.run(-1);
 	}
 }
@@ -237,7 +237,7 @@ export class NextPanelViewAction extends SwitchPanelViewAction {
 		super(id, name, panelService);
 	}
 
-	public run(): TPromise<any> {
+	public run(): Thenable<any> {
 		return super.run(1);
 	}
 }

From 8d1d201911cb447d2d892bb41297235a52bc9c3e Mon Sep 17 00:00:00 2001
From: Johannes Rieken <johannes.rieken@gmail.com>
Date: Tue, 9 Oct 2018 17:57:58 +0200
Subject: [PATCH 67/76] remove workaround for #60018

---
 .../workbench/parts/outline/electron-browser/outlinePanel.ts  | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/vs/workbench/parts/outline/electron-browser/outlinePanel.ts b/src/vs/workbench/parts/outline/electron-browser/outlinePanel.ts
index 20b19fe228f..89ec1101973 100644
--- a/src/vs/workbench/parts/outline/electron-browser/outlinePanel.ts
+++ b/src/vs/workbench/parts/outline/electron-browser/outlinePanel.ts
@@ -377,10 +377,6 @@ export class OutlinePanel extends ViewletPanel {
 	}
 
 	protected layoutBody(height: number): void {
-		if (!this.isExpanded()) {
-			// workaround https://github.com/Microsoft/vscode/issues/60018
-			return;
-		}
 		if (height !== this._cachedHeight) {
 			this._cachedHeight = height;
 			if (this._pendingLayout) {

From 2c346822d916aca70ea4dab858e72f33d80a617b Mon Sep 17 00:00:00 2001
From: SteVen Batten <6561887+sbatten@users.noreply.github.com>
Date: Tue, 9 Oct 2018 09:52:07 -0700
Subject: [PATCH 68/76] remove context listener in menubarControl (#60169)

---
 src/vs/platform/actions/common/menu.ts                    | 5 +++++
 src/vs/workbench/browser/parts/titlebar/menubarControl.ts | 3 ---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/vs/platform/actions/common/menu.ts b/src/vs/platform/actions/common/menu.ts
index 12be7bfafe5..eb36c7f8699 100644
--- a/src/vs/platform/actions/common/menu.ts
+++ b/src/vs/platform/actions/common/menu.ts
@@ -47,6 +47,11 @@ export class Menu implements IMenu {
 				if (isIMenuItem(item) && item.command.precondition) {
 					Menu._fillInKbExprKeys(item.command.precondition, keysFilter);
 				}
+
+				// keep toggled keys for event if applicable
+				if (isIMenuItem(item) && item.command.toggled) {
+					Menu._fillInKbExprKeys(item.command.toggled, keysFilter);
+				}
 			}
 
 			// subscribe to context changes
diff --git a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
index 260eaa4b47c..edaa6ace6c1 100644
--- a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
+++ b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
@@ -439,9 +439,6 @@ export class MenubarControl extends Disposable {
 		// Listen to update service
 		this.updateService.onStateChange(() => this.setupMenubar());
 
-		// Listen for context changes
-		this._register(this.contextKeyService.onDidChangeContext(() => this.setupMenubar()));
-
 		// Listen for changes in recently opened menu
 		this._register(this.windowsService.onRecentlyOpenedChange(() => { this.onRecentlyOpenedChange(); }));
 

From 11fe99a69455907f779e3eef458f2d32c11249c4 Mon Sep 17 00:00:00 2001
From: SteVen Batten <6561887+sbatten@users.noreply.github.com>
Date: Tue, 9 Oct 2018 10:00:58 -0700
Subject: [PATCH 69/76] Reducing menubar cache verbosity (#59992)

* restructure menubar data to shrink cache

* remove old menu

* avoid storing common defaults for enabled, checked, and isNative

* remove old cache data for menubar/keybindings
---
 src/vs/code/electron-main/keyboard.ts         |  114 +-
 src/vs/code/electron-main/menus.ts            | 1294 -----------------
 src/vs/platform/menubar/common/menubar.ts     |   23 +-
 .../platform/menubar/electron-main/menubar.ts |   55 +-
 .../menubar/electron-main/menubarService.ts   |    6 +-
 src/vs/platform/menubar/node/menubarIpc.ts    |    8 +-
 .../browser/parts/titlebar/menubarControl.ts  |   39 +-
 7 files changed, 71 insertions(+), 1468 deletions(-)
 delete mode 100644 src/vs/code/electron-main/menus.ts

diff --git a/src/vs/code/electron-main/keyboard.ts b/src/vs/code/electron-main/keyboard.ts
index 670068ba501..2ec1623f173 100644
--- a/src/vs/code/electron-main/keyboard.ts
+++ b/src/vs/code/electron-main/keyboard.ts
@@ -5,14 +5,7 @@
 
 import * as nativeKeymap from 'native-keymap';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { IStateService } from 'vs/platform/state/common/state';
-import { Event, Emitter, once } from 'vs/base/common/event';
-import { ConfigWatcher } from 'vs/base/node/config';
-import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { ipcMain as ipc } from 'electron';
-import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
-import { ILogService } from 'vs/platform/log/common/log';
+import { Emitter } from 'vs/base/common/event';
 
 export class KeyboardLayoutMonitor {
 
@@ -36,109 +29,4 @@ export class KeyboardLayoutMonitor {
 		}
 		return this._emitter.event(callback);
 	}
-}
-
-export interface IKeybinding {
-	id: string;
-	label: string;
-	isNative: boolean;
-}
-
-export class KeybindingsResolver {
-
-	private static readonly lastKnownKeybindingsMapStorageKey = 'lastKnownKeybindings';
-
-	private commandIds: Set<string>;
-	private keybindings: { [commandId: string]: IKeybinding };
-	private keybindingsWatcher: ConfigWatcher<IUserFriendlyKeybinding[]>;
-
-	private _onKeybindingsChanged = new Emitter<void>();
-	onKeybindingsChanged: Event<void> = this._onKeybindingsChanged.event;
-
-	constructor(
-		@IStateService private stateService: IStateService,
-		@IEnvironmentService environmentService: IEnvironmentService,
-		@IWindowsMainService private windowsMainService: IWindowsMainService,
-		@ILogService private logService: ILogService
-	) {
-		this.commandIds = new Set<string>();
-		this.keybindings = this.stateService.getItem<{ [id: string]: string; }>(KeybindingsResolver.lastKnownKeybindingsMapStorageKey) || Object.create(null);
-		this.keybindingsWatcher = new ConfigWatcher<IUserFriendlyKeybinding[]>(environmentService.appKeybindingsPath, { changeBufferDelay: 100, onError: error => this.logService.error(error) });
-
-		this.registerListeners();
-	}
-
-	private registerListeners(): void {
-
-		// Listen to resolved keybindings from window
-		ipc.on('vscode:keybindingsResolved', (event, rawKeybindings: string) => {
-			let keybindings: IKeybinding[] = [];
-			try {
-				keybindings = JSON.parse(rawKeybindings);
-			} catch (error) {
-				// Should not happen
-			}
-
-			// Fill hash map of resolved keybindings and check for changes
-			let keybindingsChanged = false;
-			let keybindingsCount = 0;
-			const resolvedKeybindings: { [commandId: string]: IKeybinding } = Object.create(null);
-			keybindings.forEach(keybinding => {
-				keybindingsCount++;
-
-				resolvedKeybindings[keybinding.id] = keybinding;
-
-				if (!this.keybindings[keybinding.id] || keybinding.label !== this.keybindings[keybinding.id].label) {
-					keybindingsChanged = true;
-				}
-			});
-
-			// A keybinding might have been unassigned, so we have to account for that too
-			if (Object.keys(this.keybindings).length !== keybindingsCount) {
-				keybindingsChanged = true;
-			}
-
-			if (keybindingsChanged) {
-				this.keybindings = resolvedKeybindings;
-				this.stateService.setItem(KeybindingsResolver.lastKnownKeybindingsMapStorageKey, this.keybindings); // keep to restore instantly after restart
-
-				this._onKeybindingsChanged.fire();
-			}
-		});
-
-		// Resolve keybindings when any first window is loaded
-		const onceOnWindowReady = once(this.windowsMainService.onWindowReady);
-		onceOnWindowReady(win => this.resolveKeybindings(win));
-
-		// Resolve keybindings again when keybindings.json changes
-		this.keybindingsWatcher.onDidUpdateConfiguration(() => this.resolveKeybindings());
-
-		// Resolve keybindings when window reloads because an installed extension could have an impact
-		this.windowsMainService.onWindowReload(() => this.resolveKeybindings());
-	}
-
-	private resolveKeybindings(win = this.windowsMainService.getLastActiveWindow()): void {
-		if (this.commandIds.size && win) {
-			const commandIds: string[] = [];
-			this.commandIds.forEach(id => commandIds.push(id));
-			win.sendWhenReady('vscode:resolveKeybindings', JSON.stringify(commandIds));
-		}
-	}
-
-	public getKeybinding(commandId: string): IKeybinding {
-		if (!commandId) {
-			return void 0;
-		}
-
-		if (!this.commandIds.has(commandId)) {
-			this.commandIds.add(commandId);
-		}
-
-		return this.keybindings[commandId];
-	}
-
-	public dispose(): void {
-		this._onKeybindingsChanged.dispose();
-		this.keybindingsWatcher.dispose();
-	}
 }
\ No newline at end of file
diff --git a/src/vs/code/electron-main/menus.ts b/src/vs/code/electron-main/menus.ts
deleted file mode 100644
index b0f6cdb7872..00000000000
--- a/src/vs/code/electron-main/menus.ts
+++ /dev/null
@@ -1,1294 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import * as nls from 'vs/nls';
-import { isMacintosh, isLinux, isWindows, language } from 'vs/base/common/platform';
-import * as arrays from 'vs/base/common/arrays';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { app, shell, Menu, MenuItem, BrowserWindow } from 'electron';
-import { OpenContext, IRunActionInWindowRequest, IWindowsService } from 'vs/platform/windows/common/windows';
-import { IConfigurationService, IConfigurationChangeEvent } from 'vs/platform/configuration/common/configuration';
-import { AutoSaveConfiguration } from 'vs/platform/files/common/files';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IUpdateService, StateType } from 'vs/platform/update/common/update';
-import product from 'vs/platform/node/product';
-import { RunOnceScheduler } from 'vs/base/common/async';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { mnemonicMenuLabel as baseMnemonicLabel, unmnemonicLabel } from 'vs/base/common/labels';
-import { KeybindingsResolver } from 'vs/code/electron-main/keyboard';
-import { IWindowsMainService, IWindowsCountChangedEvent } from 'vs/platform/windows/electron-main/windows';
-import { IHistoryMainService } from 'vs/platform/history/common/history';
-import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
-import { URI } from 'vs/base/common/uri';
-import { ILabelService } from 'vs/platform/label/common/label';
-
-interface IMenuItemClickHandler {
-	inDevTools: (contents: Electron.WebContents) => void;
-	inNoWindow: () => void;
-}
-
-const telemetryFrom = 'menu';
-
-export class CodeMenu {
-
-	private static readonly MAX_MENU_RECENT_ENTRIES = 10;
-
-	private keys = [
-		'files.autoSave',
-		'editor.multiCursorModifier',
-		'workbench.sideBar.location',
-		'workbench.statusBar.visible',
-		'workbench.activityBar.visible',
-		'window.enableMenuBarMnemonics',
-		'window.nativeTabs'
-	];
-
-	private isQuitting: boolean;
-	private appMenuInstalled: boolean;
-
-	private menuUpdater: RunOnceScheduler;
-
-	private keybindingsResolver: KeybindingsResolver;
-
-	private closeFolder: Electron.MenuItem;
-	private closeWorkspace: Electron.MenuItem;
-
-	constructor(
-		@IUpdateService private updateService: IUpdateService,
-		@IInstantiationService instantiationService: IInstantiationService,
-		@IConfigurationService private configurationService: IConfigurationService,
-		@IWindowsMainService private windowsMainService: IWindowsMainService,
-		@IWindowsService private windowsService: IWindowsService,
-		@IEnvironmentService private environmentService: IEnvironmentService,
-		@ITelemetryService private telemetryService: ITelemetryService,
-		@IHistoryMainService private historyMainService: IHistoryMainService,
-		@ILabelService private labelService: ILabelService
-	) {
-		this.menuUpdater = new RunOnceScheduler(() => this.doUpdateMenu(), 0);
-		this.keybindingsResolver = instantiationService.createInstance(KeybindingsResolver);
-
-		this.install();
-
-		this.registerListeners();
-	}
-
-	private registerListeners(): void {
-
-		// Keep flag when app quits
-		app.on('will-quit', () => {
-			this.isQuitting = true;
-		});
-
-		// Listen to some events from window service to update menu
-		this.historyMainService.onRecentlyOpenedChange(() => this.updateMenu());
-		this.windowsMainService.onWindowsCountChanged(e => this.onWindowsCountChanged(e));
-		this.windowsMainService.onActiveWindowChanged(() => this.updateWorkspaceMenuItems());
-		this.windowsMainService.onWindowReady(() => this.updateWorkspaceMenuItems());
-		this.windowsMainService.onWindowClose(() => this.updateWorkspaceMenuItems());
-
-		// Update when auto save config changes
-		this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e));
-
-		// Listen to update service
-		this.updateService.onStateChange(() => this.updateMenu());
-
-		// Listen to keybindings change
-		this.keybindingsResolver.onKeybindingsChanged(() => this.updateMenu());
-	}
-
-	private onConfigurationUpdated(event: IConfigurationChangeEvent): void {
-		if (this.keys.some(key => event.affectsConfiguration(key))) {
-			this.updateMenu();
-		}
-	}
-
-	private get currentAutoSaveSetting(): string {
-		return this.configurationService.getValue<string>('files.autoSave');
-	}
-
-	private get currentMultiCursorModifierSetting(): string {
-		return this.configurationService.getValue<string>('editor.multiCursorModifier');
-	}
-
-	private get currentSidebarLocation(): string {
-		return this.configurationService.getValue<string>('workbench.sideBar.location') || 'left';
-	}
-
-	private get currentStatusbarVisible(): boolean {
-		let statusbarVisible = this.configurationService.getValue<boolean>('workbench.statusBar.visible');
-		if (typeof statusbarVisible !== 'boolean') {
-			statusbarVisible = true;
-		}
-		return statusbarVisible;
-	}
-
-	private get currentActivityBarVisible(): boolean {
-		let activityBarVisible = this.configurationService.getValue<boolean>('workbench.activityBar.visible');
-		if (typeof activityBarVisible !== 'boolean') {
-			activityBarVisible = true;
-		}
-		return activityBarVisible;
-	}
-
-	private get currentEnableMenuBarMnemonics(): boolean {
-		let enableMenuBarMnemonics = this.configurationService.getValue<boolean>('window.enableMenuBarMnemonics');
-		if (typeof enableMenuBarMnemonics !== 'boolean') {
-			enableMenuBarMnemonics = true;
-		}
-		return enableMenuBarMnemonics;
-	}
-
-	private get currentEnableNativeTabs(): boolean {
-		let enableNativeTabs = this.configurationService.getValue<boolean>('window.nativeTabs');
-		if (typeof enableNativeTabs !== 'boolean') {
-			enableNativeTabs = false;
-		}
-		return enableNativeTabs;
-	}
-
-	private updateMenu(): void {
-		this.menuUpdater.schedule(); // buffer multiple attempts to update the menu
-	}
-
-	private doUpdateMenu(): void {
-
-		// Due to limitations in Electron, it is not possible to update menu items dynamically. The suggested
-		// workaround from Electron is to set the application menu again.
-		// See also https://github.com/electron/electron/issues/846
-		//
-		// Run delayed to prevent updating menu while it is open
-		if (!this.isQuitting) {
-			setTimeout(() => {
-				if (!this.isQuitting) {
-					this.install();
-				}
-			}, 10 /* delay this because there is an issue with updating a menu when it is open */);
-		}
-	}
-
-	private onWindowsCountChanged(e: IWindowsCountChangedEvent): void {
-		if (!isMacintosh) {
-			return;
-		}
-
-		// Update menu if window count goes from N > 0 or 0 > N to update menu item enablement
-		if ((e.oldCount === 0 && e.newCount > 0) || (e.oldCount > 0 && e.newCount === 0)) {
-			this.updateMenu();
-		}
-	}
-
-	private updateWorkspaceMenuItems(): void {
-		const window = this.windowsMainService.getLastActiveWindow();
-		const isInWorkspaceContext = window && !!window.openedWorkspace;
-		const isInFolderContext = window && !!window.openedFolderUri;
-
-		this.closeWorkspace.visible = isInWorkspaceContext;
-		this.closeFolder.visible = !isInWorkspaceContext;
-		this.closeFolder.enabled = isInFolderContext || isLinux /* https://github.com/Microsoft/vscode/issues/36431 */;
-	}
-
-	private install(): void {
-
-		// Menus
-		const menubar = new Menu();
-
-		// Mac: Application
-		let macApplicationMenuItem: Electron.MenuItem;
-		if (isMacintosh) {
-			const applicationMenu = new Menu();
-			macApplicationMenuItem = new MenuItem({ label: product.nameShort, submenu: applicationMenu });
-			this.setMacApplicationMenu(applicationMenu);
-		}
-
-		// File
-		const fileMenu = new Menu();
-		const fileMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mFile', comment: ['&& denotes a mnemonic'] }, "&&File")), submenu: fileMenu });
-		this.setFileMenu(fileMenu);
-
-		// Edit
-		const editMenu = new Menu();
-		const editMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mEdit', comment: ['&& denotes a mnemonic'] }, "&&Edit")), submenu: editMenu });
-		this.setEditMenu(editMenu);
-
-		// Selection
-		const selectionMenu = new Menu();
-		const selectionMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mSelection', comment: ['&& denotes a mnemonic'] }, "&&Selection")), submenu: selectionMenu });
-		this.setSelectionMenu(selectionMenu);
-
-		// View
-		const viewMenu = new Menu();
-		const viewMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mView', comment: ['&& denotes a mnemonic'] }, "&&View")), submenu: viewMenu });
-		this.setViewMenu(viewMenu);
-
-		// Goto
-		const gotoMenu = new Menu();
-		const gotoMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mGoto', comment: ['&& denotes a mnemonic'] }, "&&Go")), submenu: gotoMenu });
-		this.setGotoMenu(gotoMenu);
-
-		// Debug
-		const debugMenu = new Menu();
-		const debugMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mDebug', comment: ['&& denotes a mnemonic'] }, "&&Debug")), submenu: debugMenu });
-		this.setDebugMenu(debugMenu);
-
-		// Terminal
-		const terminalMenu = new Menu();
-		const terminalMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mTerminal', comment: ['&& denotes a mnemonic'] }, "&&Terminal")), submenu: terminalMenu });
-		this.setTerminalMenu(terminalMenu);
-
-		// Mac: Window
-		let macWindowMenuItem: Electron.MenuItem;
-		if (isMacintosh) {
-			const windowMenu = new Menu();
-			macWindowMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize('mWindow', "Window")), submenu: windowMenu, role: 'window' });
-			this.setMacWindowMenu(windowMenu);
-		}
-
-		// Help
-		const helpMenu = new Menu();
-		const helpMenuItem = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'mHelp', comment: ['&& denotes a mnemonic'] }, "&&Help")), submenu: helpMenu, role: 'help' });
-		this.setHelpMenu(helpMenu);
-
-
-		// Menu Structure
-		if (macApplicationMenuItem) {
-			menubar.append(macApplicationMenuItem);
-		}
-
-		menubar.append(fileMenuItem);
-		menubar.append(editMenuItem);
-		menubar.append(selectionMenuItem);
-		menubar.append(viewMenuItem);
-		menubar.append(gotoMenuItem);
-		menubar.append(debugMenuItem);
-		menubar.append(terminalMenuItem);
-
-		if (macWindowMenuItem) {
-			menubar.append(macWindowMenuItem);
-		}
-
-		menubar.append(helpMenuItem);
-
-		Menu.setApplicationMenu(menubar);
-
-		// Dock Menu
-		if (isMacintosh && !this.appMenuInstalled) {
-			this.appMenuInstalled = true;
-
-			const dockMenu = new Menu();
-			dockMenu.append(new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miNewWindow', comment: ['&& denotes a mnemonic'] }, "New &&Window")), click: () => this.windowsMainService.openNewWindow(OpenContext.DOCK) }));
-
-			app.dock.setMenu(dockMenu);
-		}
-	}
-
-	private setMacApplicationMenu(macApplicationMenu: Electron.Menu): void {
-		const about = new MenuItem({ label: nls.localize('mAbout', "About {0}", product.nameLong), role: 'about' });
-		const checkForUpdates = this.getUpdateMenuItems();
-		const preferences = this.getPreferencesMenu();
-		const servicesMenu = new Menu();
-		const services = new MenuItem({ label: nls.localize('mServices', "Services"), role: 'services', submenu: servicesMenu });
-		const hide = new MenuItem({ label: nls.localize('mHide', "Hide {0}", product.nameLong), role: 'hide', accelerator: 'Command+H' });
-		const hideOthers = new MenuItem({ label: nls.localize('mHideOthers', "Hide Others"), role: 'hideothers', accelerator: 'Command+Alt+H' });
-		const showAll = new MenuItem({ label: nls.localize('mShowAll', "Show All"), role: 'unhide' });
-		const quit = new MenuItem(this.likeAction('workbench.action.quit', {
-			label: nls.localize('miQuit', "Quit {0}", product.nameLong), click: () => {
-				if (this.windowsMainService.getWindowCount() === 0 || !!BrowserWindow.getFocusedWindow()) {
-					this.windowsMainService.quit(); // fix for https://github.com/Microsoft/vscode/issues/39191
-				}
-			}
-		}));
-
-		const actions = [about];
-		actions.push(...checkForUpdates);
-		actions.push(...[
-			__separator__(),
-			preferences,
-			__separator__(),
-			services,
-			__separator__(),
-			hide,
-			hideOthers,
-			showAll,
-			__separator__(),
-			quit
-		]);
-
-		actions.forEach(i => macApplicationMenu.append(i));
-	}
-
-	private setFileMenu(fileMenu: Electron.Menu): void {
-		const hasNoWindows = (this.windowsMainService.getWindowCount() === 0);
-
-		let newFile: Electron.MenuItem;
-		if (hasNoWindows) {
-			newFile = new MenuItem(this.likeAction('workbench.action.files.newUntitledFile', { label: this.mnemonicLabel(nls.localize({ key: 'miNewFile', comment: ['&& denotes a mnemonic'] }, "&&New File")), click: () => this.windowsMainService.openNewWindow(OpenContext.MENU) }));
-		} else {
-			newFile = this.createMenuItem(nls.localize({ key: 'miNewFile', comment: ['&& denotes a mnemonic'] }, "&&New File"), 'workbench.action.files.newUntitledFile');
-		}
-
-		let open: Electron.MenuItem;
-		if (hasNoWindows) {
-			open = new MenuItem(this.likeAction('workbench.action.files.openFileFolder', { label: this.mnemonicLabel(nls.localize({ key: 'miOpen', comment: ['&& denotes a mnemonic'] }, "&&Open...")), click: (menuItem, win, event) => this.windowsMainService.pickFileFolderAndOpen({ forceNewWindow: this.isOptionClick(event), telemetryExtraData: { from: telemetryFrom } }) }));
-		} else {
-			open = this.createMenuItem(nls.localize({ key: 'miOpen', comment: ['&& denotes a mnemonic'] }, "&&Open..."), ['workbench.action.files.openFileFolder', 'workbench.action.files.openFileFolderInNewWindow']);
-		}
-
-		let openWorkspace: Electron.MenuItem;
-		if (hasNoWindows) {
-			openWorkspace = new MenuItem(this.likeAction('workbench.action.openWorkspace', { label: this.mnemonicLabel(nls.localize({ key: 'miOpenWorkspace', comment: ['&& denotes a mnemonic'] }, "Open Wor&&kspace...")), click: (menuItem, win, event) => this.windowsMainService.pickWorkspaceAndOpen({ forceNewWindow: this.isOptionClick(event), telemetryExtraData: { from: telemetryFrom } }) }));
-		} else {
-			openWorkspace = this.createMenuItem(nls.localize({ key: 'miOpenWorkspace', comment: ['&& denotes a mnemonic'] }, "Open Wor&&kspace..."), ['workbench.action.openWorkspace', 'workbench.action.openWorkspaceInNewWindow']);
-		}
-
-		let openFolder: Electron.MenuItem;
-		if (hasNoWindows) {
-			openFolder = new MenuItem(this.likeAction('workbench.action.files.openFolder', { label: this.mnemonicLabel(nls.localize({ key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] }, "Open &&Folder...")), click: (menuItem, win, event) => this.windowsMainService.pickFolderAndOpen({ forceNewWindow: this.isOptionClick(event), telemetryExtraData: { from: telemetryFrom } }) }));
-		} else {
-			openFolder = this.createMenuItem(nls.localize({ key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] }, "Open &&Folder..."), ['workbench.action.files.openFolder', 'workbench.action.files.openFolderInNewWindow']);
-		}
-
-		let openFile: Electron.MenuItem;
-		if (hasNoWindows) {
-			openFile = new MenuItem(this.likeAction('workbench.action.files.openFile', { label: this.mnemonicLabel(nls.localize({ key: 'miOpenFile', comment: ['&& denotes a mnemonic'] }, "&&Open File...")), click: (menuItem, win, event) => this.windowsMainService.pickFileAndOpen({ forceNewWindow: this.isOptionClick(event), telemetryExtraData: { from: telemetryFrom } }) }));
-		} else {
-			openFile = this.createMenuItem(nls.localize({ key: 'miOpenFile', comment: ['&& denotes a mnemonic'] }, "&&Open File..."), ['workbench.action.files.openFile', 'workbench.action.files.openFileInNewWindow']);
-		}
-
-		const openRecentMenu = new Menu();
-		this.setOpenRecentMenu(openRecentMenu);
-		const openRecent = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miOpenRecent', comment: ['&& denotes a mnemonic'] }, "Open &&Recent")), submenu: openRecentMenu, enabled: openRecentMenu.items.length > 0 });
-
-		const saveWorkspaceAs = this.createMenuItem(nls.localize('miSaveWorkspaceAs', "Save Workspace As..."), 'workbench.action.saveWorkspaceAs');
-		const addFolder = this.createMenuItem(nls.localize({ key: 'miAddFolderToWorkspace', comment: ['&& denotes a mnemonic'] }, "A&&dd Folder to Workspace..."), 'workbench.action.addRootFolder');
-
-		const saveFile = this.createMenuItem(nls.localize({ key: 'miSave', comment: ['&& denotes a mnemonic'] }, "&&Save"), 'workbench.action.files.save');
-		const saveFileAs = this.createMenuItem(nls.localize({ key: 'miSaveAs', comment: ['&& denotes a mnemonic'] }, "Save &&As..."), 'workbench.action.files.saveAs');
-		const saveAllFiles = this.createMenuItem(nls.localize({ key: 'miSaveAll', comment: ['&& denotes a mnemonic'] }, "Save A&&ll"), 'workbench.action.files.saveAll');
-
-		const autoSaveEnabled = [AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE].some(s => this.currentAutoSaveSetting === s);
-
-		const autoSave = this.createMenuItem(this.mnemonicLabel(nls.localize('miAutoSave', "A&&uto Save")), 'workbench.action.toggleAutoSave', this.windowsMainService.getWindowCount() > 0, autoSaveEnabled);
-
-		const preferences = this.getPreferencesMenu();
-
-		const newWindow = new MenuItem(this.likeAction('workbench.action.newWindow', { label: this.mnemonicLabel(nls.localize({ key: 'miNewWindow', comment: ['&& denotes a mnemonic'] }, "New &&Window")), click: () => this.windowsMainService.openNewWindow(OpenContext.MENU) }));
-		const revertFile = this.createMenuItem(nls.localize({ key: 'miRevert', comment: ['&& denotes a mnemonic'] }, "Re&&vert File"), 'workbench.action.files.revert');
-		const closeWindow = new MenuItem(this.likeAction('workbench.action.closeWindow', { label: this.mnemonicLabel(nls.localize({ key: 'miCloseWindow', comment: ['&& denotes a mnemonic'] }, "Clos&&e Window")), click: () => this.windowsMainService.getLastActiveWindow().win.close(), enabled: this.windowsMainService.getWindowCount() > 0 }));
-
-		this.closeWorkspace = this.createMenuItem(nls.localize({ key: 'miCloseWorkspace', comment: ['&& denotes a mnemonic'] }, "Close &&Workspace"), 'workbench.action.closeFolder');
-		this.closeFolder = this.createMenuItem(nls.localize({ key: 'miCloseFolder', comment: ['&& denotes a mnemonic'] }, "Close &&Folder"), 'workbench.action.closeFolder');
-
-		const closeEditor = this.createMenuItem(nls.localize({ key: 'miCloseEditor', comment: ['&& denotes a mnemonic'] }, "&&Close Editor"), 'workbench.action.closeActiveEditor');
-
-		const exit = new MenuItem(this.likeAction('workbench.action.quit', { label: this.mnemonicLabel(nls.localize({ key: 'miExit', comment: ['&& denotes a mnemonic'] }, "E&&xit")), click: () => this.windowsMainService.quit() }));
-
-		this.updateWorkspaceMenuItems();
-
-		arrays.coalesce([
-			newFile,
-			newWindow,
-			__separator__(),
-			isMacintosh ? open : null,
-			!isMacintosh ? openFile : null,
-			!isMacintosh ? openFolder : null,
-			openWorkspace,
-			openRecent,
-			__separator__(),
-			addFolder,
-			saveWorkspaceAs,
-			__separator__(),
-			saveFile,
-			saveFileAs,
-			saveAllFiles,
-			__separator__(),
-			autoSave,
-			__separator__(),
-			!isMacintosh ? preferences : null,
-			!isMacintosh ? __separator__() : null,
-			revertFile,
-			closeEditor,
-			this.closeWorkspace,
-			this.closeFolder,
-			closeWindow,
-			!isMacintosh ? __separator__() : null,
-			!isMacintosh ? exit : null
-		]).forEach(item => fileMenu.append(item));
-	}
-
-	private getPreferencesMenu(): Electron.MenuItem {
-		const settings = this.createMenuItem(nls.localize({ key: 'miOpenSettings', comment: ['&& denotes a mnemonic'] }, "&&Settings"), 'workbench.action.openSettings');
-		const extensions = this.createMenuItem(nls.localize({ key: 'miOpenExtensions', comment: ['&& denotes a mnemonic'] }, '&&Extensions'), 'workbench.view.extensions');
-		const kebindingSettings = this.createMenuItem(nls.localize({ key: 'miOpenKeymap', comment: ['&& denotes a mnemonic'] }, "&&Keyboard Shortcuts"), 'workbench.action.openGlobalKeybindings');
-		const keymapExtensions = this.createMenuItem(nls.localize({ key: 'miOpenKeymapExtensions', comment: ['&& denotes a mnemonic'] }, "&&Keymaps"), 'workbench.extensions.action.showRecommendedKeymapExtensions');
-		const snippetsSettings = this.createMenuItem(nls.localize({ key: 'miOpenSnippets', comment: ['&& denotes a mnemonic'] }, "User &&Snippets"), 'workbench.action.openSnippets');
-		const colorThemeSelection = this.createMenuItem(nls.localize({ key: 'miSelectColorTheme', comment: ['&& denotes a mnemonic'] }, "&&Color Theme"), 'workbench.action.selectTheme');
-		const iconThemeSelection = this.createMenuItem(nls.localize({ key: 'miSelectIconTheme', comment: ['&& denotes a mnemonic'] }, "File &&Icon Theme"), 'workbench.action.selectIconTheme');
-
-		const preferencesMenu = new Menu();
-		preferencesMenu.append(settings);
-		preferencesMenu.append(extensions);
-		preferencesMenu.append(__separator__());
-		preferencesMenu.append(kebindingSettings);
-		preferencesMenu.append(keymapExtensions);
-		preferencesMenu.append(__separator__());
-		preferencesMenu.append(snippetsSettings);
-		preferencesMenu.append(__separator__());
-		preferencesMenu.append(colorThemeSelection);
-		preferencesMenu.append(iconThemeSelection);
-
-		return new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miPreferences', comment: ['&& denotes a mnemonic'] }, "&&Preferences")), submenu: preferencesMenu });
-	}
-
-	private setOpenRecentMenu(openRecentMenu: Electron.Menu): void {
-		openRecentMenu.append(this.createMenuItem(nls.localize({ key: 'miReopenClosedEditor', comment: ['&& denotes a mnemonic'] }, "&&Reopen Closed Editor"), 'workbench.action.reopenClosedEditor'));
-
-		const { workspaces, files } = this.historyMainService.getRecentlyOpened();
-
-		// Workspaces
-		if (workspaces.length > 0) {
-			openRecentMenu.append(__separator__());
-
-			for (let i = 0; i < CodeMenu.MAX_MENU_RECENT_ENTRIES && i < workspaces.length; i++) {
-				openRecentMenu.append(this.createOpenRecentMenuItem(workspaces[i], 'openRecentWorkspace', false));
-			}
-		}
-
-		// Files
-		if (files.length > 0) {
-			openRecentMenu.append(__separator__());
-
-			for (let i = 0; i < CodeMenu.MAX_MENU_RECENT_ENTRIES && i < files.length; i++) {
-				openRecentMenu.append(this.createOpenRecentMenuItem(files[i], 'openRecentFile', true));
-			}
-		}
-
-		if (workspaces.length || files.length) {
-			const hasNoWindows = (this.windowsMainService.getWindowCount() === 0);
-
-			openRecentMenu.append(__separator__());
-			openRecentMenu.append(this.createMenuItem(nls.localize({ key: 'miMore', comment: ['&& denotes a mnemonic'] }, "&&More..."), 'workbench.action.openRecent'));
-			openRecentMenu.append(__separator__());
-
-			let clearRecentFiles: MenuItem;
-			if (hasNoWindows) {
-				clearRecentFiles = new MenuItem(this.likeAction('workbench.action.clearRecentFiles', { label: this.mnemonicLabel(nls.localize({ key: 'miClearRecentOpen', comment: ['&& denotes a mnemonic'] }, "&&Clear Recently Opened")), click: () => this.historyMainService.clearRecentlyOpened() }));
-			} else {
-				clearRecentFiles = this.createMenuItem(nls.localize({ key: 'miClearRecentOpen', comment: ['&& denotes a mnemonic'] }, "&&Clear Recently Opened"), 'workbench.action.clearRecentFiles');
-			}
-
-			openRecentMenu.append(clearRecentFiles);
-		}
-	}
-
-	private createOpenRecentMenuItem(workspace: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string, commandId: string, isFile: boolean): Electron.MenuItem {
-		let label: string;
-		let uri: URI;
-		if (isSingleFolderWorkspaceIdentifier(workspace)) {
-			label = unmnemonicLabel(this.labelService.getWorkspaceLabel(workspace, { verbose: true }));
-			uri = workspace;
-		} else if (isWorkspaceIdentifier(workspace)) {
-			label = this.labelService.getWorkspaceLabel(workspace, { verbose: true });
-			uri = URI.file(workspace.configPath);
-		} else {
-			uri = URI.file(workspace);
-			label = unmnemonicLabel(this.labelService.getUriLabel(uri));
-		}
-
-		return new MenuItem(this.likeAction(commandId, {
-			label,
-			click: (menuItem, win, event) => {
-				const openInNewWindow = this.isOptionClick(event);
-				const success = this.windowsMainService.open({
-					context: OpenContext.MENU,
-					cli: this.environmentService.args,
-					urisToOpen: [uri],
-					forceNewWindow: openInNewWindow,
-					forceOpenWorkspaceAsFile: isFile
-				}).length > 0;
-
-				if (!success) {
-					this.historyMainService.removeFromRecentlyOpened([workspace]);
-				}
-			}
-		}, false));
-	}
-
-	private isOptionClick(event: Electron.Event): boolean {
-		return event && ((!isMacintosh && (event.ctrlKey || event.shiftKey)) || (isMacintosh && (event.metaKey || event.altKey)));
-	}
-
-	private createRoleMenuItem(label: string, commandId: string, role: any): Electron.MenuItem {
-		const options: Electron.MenuItemConstructorOptions = {
-			label: this.mnemonicLabel(label),
-			role,
-			enabled: true
-		};
-
-		return new MenuItem(this.withKeybinding(commandId, options));
-	}
-
-	private setEditMenu(winLinuxEditMenu: Electron.Menu): void {
-		let undo: Electron.MenuItem;
-		let redo: Electron.MenuItem;
-		let cut: Electron.MenuItem;
-		let copy: Electron.MenuItem;
-		let paste: Electron.MenuItem;
-
-		if (isMacintosh) {
-			undo = this.createContextAwareMenuItem(nls.localize({ key: 'miUndo', comment: ['&& denotes a mnemonic'] }, "&&Undo"), 'undo', {
-				inDevTools: devTools => devTools.undo(),
-				inNoWindow: () => Menu.sendActionToFirstResponder('undo:')
-			});
-			redo = this.createContextAwareMenuItem(nls.localize({ key: 'miRedo', comment: ['&& denotes a mnemonic'] }, "&&Redo"), 'redo', {
-				inDevTools: devTools => devTools.redo(),
-				inNoWindow: () => Menu.sendActionToFirstResponder('redo:')
-			});
-			cut = this.createRoleMenuItem(nls.localize({ key: 'miCut', comment: ['&& denotes a mnemonic'] }, "Cu&&t"), 'editor.action.clipboardCutAction', 'cut');
-			copy = this.createRoleMenuItem(nls.localize({ key: 'miCopy', comment: ['&& denotes a mnemonic'] }, "&&Copy"), 'editor.action.clipboardCopyAction', 'copy');
-			paste = this.createRoleMenuItem(nls.localize({ key: 'miPaste', comment: ['&& denotes a mnemonic'] }, "&&Paste"), 'editor.action.clipboardPasteAction', 'paste');
-		} else {
-			undo = this.createMenuItem(nls.localize({ key: 'miUndo', comment: ['&& denotes a mnemonic'] }, "&&Undo"), 'undo');
-			redo = this.createMenuItem(nls.localize({ key: 'miRedo', comment: ['&& denotes a mnemonic'] }, "&&Redo"), 'redo');
-			cut = this.createMenuItem(nls.localize({ key: 'miCut', comment: ['&& denotes a mnemonic'] }, "Cu&&t"), 'editor.action.clipboardCutAction');
-			copy = this.createMenuItem(nls.localize({ key: 'miCopy', comment: ['&& denotes a mnemonic'] }, "&&Copy"), 'editor.action.clipboardCopyAction');
-			paste = this.createMenuItem(nls.localize({ key: 'miPaste', comment: ['&& denotes a mnemonic'] }, "&&Paste"), 'editor.action.clipboardPasteAction');
-		}
-
-		const find = this.createMenuItem(nls.localize({ key: 'miFind', comment: ['&& denotes a mnemonic'] }, "&&Find"), 'actions.find');
-		const replace = this.createMenuItem(nls.localize({ key: 'miReplace', comment: ['&& denotes a mnemonic'] }, "&&Replace"), 'editor.action.startFindReplaceAction');
-		const findInFiles = this.createMenuItem(nls.localize({ key: 'miFindInFiles', comment: ['&& denotes a mnemonic'] }, "Find &&in Files"), 'workbench.action.findInFiles');
-		const replaceInFiles = this.createMenuItem(nls.localize({ key: 'miReplaceInFiles', comment: ['&& denotes a mnemonic'] }, "Replace &&in Files"), 'workbench.action.replaceInFiles');
-
-		const emmetExpandAbbreviation = this.createMenuItem(nls.localize({ key: 'miEmmetExpandAbbreviation', comment: ['&& denotes a mnemonic'] }, "Emmet: E&&xpand Abbreviation"), 'editor.emmet.action.expandAbbreviation');
-		const showEmmetCommands = this.createMenuItem(nls.localize({ key: 'miShowEmmetCommands', comment: ['&& denotes a mnemonic'] }, "E&&mmet..."), 'workbench.action.showEmmetCommands');
-		const toggleLineComment = this.createMenuItem(nls.localize({ key: 'miToggleLineComment', comment: ['&& denotes a mnemonic'] }, "&&Toggle Line Comment"), 'editor.action.commentLine');
-		const toggleBlockComment = this.createMenuItem(nls.localize({ key: 'miToggleBlockComment', comment: ['&& denotes a mnemonic'] }, "Toggle &&Block Comment"), 'editor.action.blockComment');
-
-		[
-			undo,
-			redo,
-			__separator__(),
-			cut,
-			copy,
-			paste,
-			__separator__(),
-			find,
-			replace,
-			__separator__(),
-			findInFiles,
-			replaceInFiles,
-			__separator__(),
-			toggleLineComment,
-			toggleBlockComment,
-			emmetExpandAbbreviation,
-			showEmmetCommands
-		].forEach(item => winLinuxEditMenu.append(item));
-	}
-
-	private setSelectionMenu(winLinuxEditMenu: Electron.Menu): void {
-		let multiCursorModifierLabel: string;
-		if (this.currentMultiCursorModifierSetting === 'ctrlCmd') {
-			multiCursorModifierLabel = nls.localize('miMultiCursorAlt', "Switch to Alt+Click for Multi-Cursor"); // The default has been overwritten
-		} else {
-			multiCursorModifierLabel = (
-				isMacintosh
-					? nls.localize('miMultiCursorCmd', "Switch to Cmd+Click for Multi-Cursor")
-					: nls.localize('miMultiCursorCtrl', "Switch to Ctrl+Click for Multi-Cursor")
-			);
-		}
-
-		const multicursorModifier = this.createMenuItem(multiCursorModifierLabel, 'workbench.action.toggleMultiCursorModifier');
-		const insertCursorAbove = this.createMenuItem(nls.localize({ key: 'miInsertCursorAbove', comment: ['&& denotes a mnemonic'] }, "&&Add Cursor Above"), 'editor.action.insertCursorAbove');
-		const insertCursorBelow = this.createMenuItem(nls.localize({ key: 'miInsertCursorBelow', comment: ['&& denotes a mnemonic'] }, "A&&dd Cursor Below"), 'editor.action.insertCursorBelow');
-		const insertCursorAtEndOfEachLineSelected = this.createMenuItem(nls.localize({ key: 'miInsertCursorAtEndOfEachLineSelected', comment: ['&& denotes a mnemonic'] }, "Add C&&ursors to Line Ends"), 'editor.action.insertCursorAtEndOfEachLineSelected');
-		const addSelectionToNextFindMatch = this.createMenuItem(nls.localize({ key: 'miAddSelectionToNextFindMatch', comment: ['&& denotes a mnemonic'] }, "Add &&Next Occurrence"), 'editor.action.addSelectionToNextFindMatch');
-		const addSelectionToPreviousFindMatch = this.createMenuItem(nls.localize({ key: 'miAddSelectionToPreviousFindMatch', comment: ['&& denotes a mnemonic'] }, "Add P&&revious Occurrence"), 'editor.action.addSelectionToPreviousFindMatch');
-		const selectHighlights = this.createMenuItem(nls.localize({ key: 'miSelectHighlights', comment: ['&& denotes a mnemonic'] }, "Select All &&Occurrences"), 'editor.action.selectHighlights');
-
-		const copyLinesUp = this.createMenuItem(nls.localize({ key: 'miCopyLinesUp', comment: ['&& denotes a mnemonic'] }, "&&Copy Line Up"), 'editor.action.copyLinesUpAction');
-		const copyLinesDown = this.createMenuItem(nls.localize({ key: 'miCopyLinesDown', comment: ['&& denotes a mnemonic'] }, "Co&&py Line Down"), 'editor.action.copyLinesDownAction');
-		const moveLinesUp = this.createMenuItem(nls.localize({ key: 'miMoveLinesUp', comment: ['&& denotes a mnemonic'] }, "Mo&&ve Line Up"), 'editor.action.moveLinesUpAction');
-		const moveLinesDown = this.createMenuItem(nls.localize({ key: 'miMoveLinesDown', comment: ['&& denotes a mnemonic'] }, "Move &&Line Down"), 'editor.action.moveLinesDownAction');
-
-		let selectAll: Electron.MenuItem;
-		if (isMacintosh) {
-			selectAll = this.createContextAwareMenuItem(nls.localize({ key: 'miSelectAll', comment: ['&& denotes a mnemonic'] }, "&&Select All"), 'editor.action.selectAll', {
-				inDevTools: devTools => devTools.selectAll(),
-				inNoWindow: () => Menu.sendActionToFirstResponder('selectAll:')
-			});
-		} else {
-			selectAll = this.createMenuItem(nls.localize({ key: 'miSelectAll', comment: ['&& denotes a mnemonic'] }, "&&Select All"), 'editor.action.selectAll');
-		}
-		const smartSelectGrow = this.createMenuItem(nls.localize({ key: 'miSmartSelectGrow', comment: ['&& denotes a mnemonic'] }, "&&Expand Selection"), 'editor.action.smartSelect.grow');
-		const smartSelectshrink = this.createMenuItem(nls.localize({ key: 'miSmartSelectShrink', comment: ['&& denotes a mnemonic'] }, "&&Shrink Selection"), 'editor.action.smartSelect.shrink');
-
-		[
-			selectAll,
-			smartSelectGrow,
-			smartSelectshrink,
-			__separator__(),
-			copyLinesUp,
-			copyLinesDown,
-			moveLinesUp,
-			moveLinesDown,
-			__separator__(),
-			multicursorModifier,
-			insertCursorAbove,
-			insertCursorBelow,
-			insertCursorAtEndOfEachLineSelected,
-			addSelectionToNextFindMatch,
-			addSelectionToPreviousFindMatch,
-			selectHighlights,
-		].forEach(item => winLinuxEditMenu.append(item));
-	}
-
-	private setViewMenu(viewMenu: Electron.Menu): void {
-		const commands = this.createMenuItem(nls.localize({ key: 'miCommandPalette', comment: ['&& denotes a mnemonic'] }, "&&Command Palette..."), 'workbench.action.showCommands');
-		const openView = this.createMenuItem(nls.localize({ key: 'miOpenView', comment: ['&& denotes a mnemonic'] }, "&&Open View..."), 'workbench.action.openView');
-
-		// Views
-		const explorer = this.createMenuItem(nls.localize({ key: 'miViewExplorer', comment: ['&& denotes a mnemonic'] }, "&&Explorer"), 'workbench.view.explorer');
-		const search = this.createMenuItem(nls.localize({ key: 'miViewSearch', comment: ['&& denotes a mnemonic'] }, "&&Search"), 'workbench.view.search');
-		const scm = this.createMenuItem(nls.localize({ key: 'miViewSCM', comment: ['&& denotes a mnemonic'] }, "S&&CM"), 'workbench.view.scm');
-		const debug = this.createMenuItem(nls.localize({ key: 'miViewDebug', comment: ['&& denotes a mnemonic'] }, "&&Debug"), 'workbench.view.debug');
-		const extensions = this.createMenuItem(nls.localize({ key: 'miViewExtensions', comment: ['&& denotes a mnemonic'] }, "E&&xtensions"), 'workbench.view.extensions');
-
-		// Panels
-		const output = this.createMenuItem(nls.localize({ key: 'miToggleOutput', comment: ['&& denotes a mnemonic'] }, "&&Output"), 'workbench.action.output.toggleOutput');
-		const debugConsole = this.createMenuItem(nls.localize({ key: 'miToggleDebugConsole', comment: ['&& denotes a mnemonic'] }, "De&&bug Console"), 'workbench.debug.action.toggleRepl');
-		const terminal = this.createMenuItem(nls.localize({ key: 'miToggleTerminal', comment: ['&& denotes a mnemonic'] }, "&&Terminal"), 'workbench.action.terminal.toggleTerminal');
-		const problems = this.createMenuItem(nls.localize({ key: 'miMarker', comment: ['&& denotes a mnemonic'] }, "&&Problems"), 'workbench.actions.view.problems');
-
-		// Appearance
-
-		const appearanceMenu = new Menu();
-
-		const fullscreen = new MenuItem(this.withKeybinding('workbench.action.toggleFullScreen', { label: this.mnemonicLabel(nls.localize({ key: 'miToggleFullScreen', comment: ['&& denotes a mnemonic'] }, "Toggle &&Full Screen")), click: () => this.windowsMainService.getLastActiveWindow().toggleFullScreen(), enabled: this.windowsMainService.getWindowCount() > 0 }));
-		const toggleZenMode = this.createMenuItem(nls.localize('miToggleZenMode', "Toggle Zen Mode"), 'workbench.action.toggleZenMode');
-		const toggleCenteredLayout = this.createMenuItem(nls.localize('miToggleCenteredLayout', "Toggle Centered Layout"), 'workbench.action.toggleCenteredLayout');
-		const toggleMenuBar = this.createMenuItem(nls.localize({ key: 'miToggleMenuBar', comment: ['&& denotes a mnemonic'] }, "Toggle Menu &&Bar"), 'workbench.action.toggleMenuBar');
-
-		const toggleSidebar = this.createMenuItem(nls.localize({ key: 'miToggleSidebar', comment: ['&& denotes a mnemonic'] }, "&&Toggle Side Bar"), 'workbench.action.toggleSidebarVisibility');
-
-		let moveSideBarLabel: string;
-		if (this.currentSidebarLocation !== 'right') {
-			moveSideBarLabel = nls.localize({ key: 'miMoveSidebarRight', comment: ['&& denotes a mnemonic'] }, "&&Move Side Bar Right");
-		} else {
-			moveSideBarLabel = nls.localize({ key: 'miMoveSidebarLeft', comment: ['&& denotes a mnemonic'] }, "&&Move Side Bar Left");
-		}
-
-		const moveSidebar = this.createMenuItem(moveSideBarLabel, 'workbench.action.toggleSidebarPosition');
-		const movePanel = this.createMenuItem(nls.localize('togglePanelPosition', "Toggle Panel Position"), 'workbench.action.togglePanelPosition');
-		const togglePanel = this.createMenuItem(nls.localize({ key: 'miTogglePanel', comment: ['&& denotes a mnemonic'] }, "Toggle &&Panel"), 'workbench.action.togglePanel');
-
-		let statusBarLabel: string;
-		if (this.currentStatusbarVisible) {
-			statusBarLabel = nls.localize({ key: 'miHideStatusbar', comment: ['&& denotes a mnemonic'] }, "&&Hide Status Bar");
-		} else {
-			statusBarLabel = nls.localize({ key: 'miShowStatusbar', comment: ['&& denotes a mnemonic'] }, "&&Show Status Bar");
-		}
-		const toggleStatusbar = this.createMenuItem(statusBarLabel, 'workbench.action.toggleStatusbarVisibility');
-
-		let activityBarLabel: string;
-		if (this.currentActivityBarVisible) {
-			activityBarLabel = nls.localize({ key: 'miHideActivityBar', comment: ['&& denotes a mnemonic'] }, "Hide &&Activity Bar");
-		} else {
-			activityBarLabel = nls.localize({ key: 'miShowActivityBar', comment: ['&& denotes a mnemonic'] }, "Show &&Activity Bar");
-		}
-		const toggleActivtyBar = this.createMenuItem(activityBarLabel, 'workbench.action.toggleActivityBarVisibility');
-
-		const zoomIn = this.createMenuItem(nls.localize({ key: 'miZoomIn', comment: ['&& denotes a mnemonic'] }, "&&Zoom In"), 'workbench.action.zoomIn');
-		const zoomOut = this.createMenuItem(nls.localize({ key: 'miZoomOut', comment: ['&& denotes a mnemonic'] }, "Zoom O&&ut"), 'workbench.action.zoomOut');
-		const resetZoom = this.createMenuItem(nls.localize({ key: 'miZoomReset', comment: ['&& denotes a mnemonic'] }, "&&Reset Zoom"), 'workbench.action.zoomReset');
-
-		arrays.coalesce([
-			fullscreen,
-			toggleZenMode,
-			toggleCenteredLayout,
-			isWindows || isLinux ? toggleMenuBar : void 0,
-			__separator__(),
-			moveSidebar,
-			toggleSidebar,
-			movePanel,
-			togglePanel,
-			toggleStatusbar,
-			toggleActivtyBar,
-			__separator__(),
-			zoomIn,
-			zoomOut,
-			resetZoom
-		]).forEach(item => appearanceMenu.append(item));
-
-		const appearance = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miAppearance', comment: ['&& denotes a mnemonic'] }, "&&Appearance")), submenu: appearanceMenu });
-
-		// Editor Layout
-
-		const editorLayoutMenu = new Menu();
-
-		const splitEditorUp = this.createMenuItem(nls.localize({ key: 'miSplitEditorUp', comment: ['&& denotes a mnemonic'] }, "Split &&Up"), 'workbench.action.splitEditorUp');
-		const splitEditorDown = this.createMenuItem(nls.localize({ key: 'miSplitEditorDown', comment: ['&& denotes a mnemonic'] }, "Split &&Down"), 'workbench.action.splitEditorDown');
-		const splitEditorLeft = this.createMenuItem(nls.localize({ key: 'miSplitEditorLeft', comment: ['&& denotes a mnemonic'] }, "Split &&Left"), 'workbench.action.splitEditorLeft');
-		const splitEditorRight = this.createMenuItem(nls.localize({ key: 'miSplitEditorRight', comment: ['&& denotes a mnemonic'] }, "Split &&Right"), 'workbench.action.splitEditorRight');
-
-		const singleColumnEditorLayout = this.createMenuItem(nls.localize({ key: 'miSingleColumnEditorLayout', comment: ['&& denotes a mnemonic'] }, "&&Single"), 'workbench.action.editorLayoutSingle');
-		const twoColumnsEditorLayout = this.createMenuItem(nls.localize({ key: 'miTwoColumnsEditorLayout', comment: ['&& denotes a mnemonic'] }, "&&Two Columns"), 'workbench.action.editorLayoutTwoColumns');
-		const threeColumnsEditorLayout = this.createMenuItem(nls.localize({ key: 'miThreeColumnsEditorLayout', comment: ['&& denotes a mnemonic'] }, "T&&hree Columns"), 'workbench.action.editorLayoutThreeColumns');
-		const twoRowsEditorLayout = this.createMenuItem(nls.localize({ key: 'miTwoRowsEditorLayout', comment: ['&& denotes a mnemonic'] }, "T&&wo Rows"), 'workbench.action.editorLayoutTwoRows');
-		const threeRowsEditorLayout = this.createMenuItem(nls.localize({ key: 'miThreeRowsEditorLayout', comment: ['&& denotes a mnemonic'] }, "Three &&Rows"), 'workbench.action.editorLayoutThreeRows');
-		const twoByTwoGridEditorLayout = this.createMenuItem(nls.localize({ key: 'miTwoByTwoGridEditorLayout', comment: ['&& denotes a mnemonic'] }, "&&Grid (2x2)"), 'workbench.action.editorLayoutTwoByTwoGrid');
-		const twoRowsRightEditorLayout = this.createMenuItem(nls.localize({ key: 'miTwoRowsRightEditorLayout', comment: ['&& denotes a mnemonic'] }, "Two R&&ows Right"), 'workbench.action.editorLayoutTwoRowsRight');
-		const twoColumnsBottomEditorLayout = this.createMenuItem(nls.localize({ key: 'miTwoColumnsBottomEditorLayout', comment: ['&& denotes a mnemonic'] }, "Two &&Columns Bottom"), 'workbench.action.editorLayoutTwoColumnsBottom');
-
-		const toggleEditorLayout = this.createMenuItem(nls.localize({ key: 'miToggleEditorLayout', comment: ['&& denotes a mnemonic'] }, "Flip &&Layout"), 'workbench.action.toggleEditorGroupLayout');
-
-		[
-			splitEditorUp,
-			splitEditorDown,
-			splitEditorLeft,
-			splitEditorRight,
-			__separator__(),
-			singleColumnEditorLayout,
-			twoColumnsEditorLayout,
-			threeColumnsEditorLayout,
-			twoRowsEditorLayout,
-			threeRowsEditorLayout,
-			twoByTwoGridEditorLayout,
-			twoRowsRightEditorLayout,
-			twoColumnsBottomEditorLayout,
-			__separator__(),
-			toggleEditorLayout
-		].forEach(item => editorLayoutMenu.append(item));
-
-		const editorLayout = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miEditorLayout', comment: ['&& denotes a mnemonic'] }, "Editor &&Layout")), submenu: editorLayoutMenu });
-
-		const toggleWordWrap = this.createMenuItem(nls.localize({ key: 'miToggleWordWrap', comment: ['&& denotes a mnemonic'] }, "Toggle &&Word Wrap"), 'editor.action.toggleWordWrap');
-		const toggleMinimap = this.createMenuItem(nls.localize({ key: 'miToggleMinimap', comment: ['&& denotes a mnemonic'] }, "Toggle &&Minimap"), 'editor.action.toggleMinimap');
-		const toggleRenderWhitespace = this.createMenuItem(nls.localize({ key: 'miToggleRenderWhitespace', comment: ['&& denotes a mnemonic'] }, "Toggle &&Render Whitespace"), 'editor.action.toggleRenderWhitespace');
-		const toggleRenderControlCharacters = this.createMenuItem(nls.localize({ key: 'miToggleRenderControlCharacters', comment: ['&& denotes a mnemonic'] }, "Toggle &&Control Characters"), 'editor.action.toggleRenderControlCharacter');
-		const toggleBreadcrumbs = this.createMenuItem(nls.localize({ key: 'miToggleBreadcrumbs', comment: ['&& denotes a mnemonic'] }, "Toggle &&Breadcrumbs"), 'breadcrumbs.toggle');
-
-		arrays.coalesce([
-			commands,
-			openView,
-			__separator__(),
-			appearance,
-			editorLayout,
-			__separator__(),
-			explorer,
-			search,
-			scm,
-			debug,
-			extensions,
-			__separator__(),
-			output,
-			problems,
-			debugConsole,
-			terminal,
-			__separator__(),
-			toggleWordWrap,
-			toggleMinimap,
-			toggleRenderWhitespace,
-			toggleRenderControlCharacters,
-			toggleBreadcrumbs
-		]).forEach(item => viewMenu.append(item));
-	}
-
-	private setGotoMenu(gotoMenu: Electron.Menu): void {
-		const back = this.createMenuItem(nls.localize({ key: 'miBack', comment: ['&& denotes a mnemonic'] }, "&&Back"), 'workbench.action.navigateBack');
-		const forward = this.createMenuItem(nls.localize({ key: 'miForward', comment: ['&& denotes a mnemonic'] }, "&&Forward"), 'workbench.action.navigateForward');
-
-		const switchEditorMenu = new Menu();
-
-		const nextEditor = this.createMenuItem(nls.localize({ key: 'miNextEditor', comment: ['&& denotes a mnemonic'] }, "&&Next Editor"), 'workbench.action.nextEditor');
-		const previousEditor = this.createMenuItem(nls.localize({ key: 'miPreviousEditor', comment: ['&& denotes a mnemonic'] }, "&&Previous Editor"), 'workbench.action.previousEditor');
-		const nextEditorInGroup = this.createMenuItem(nls.localize({ key: 'miNextEditorInGroup', comment: ['&& denotes a mnemonic'] }, "&&Next Used Editor in Group"), 'workbench.action.openNextRecentlyUsedEditorInGroup');
-		const previousEditorInGroup = this.createMenuItem(nls.localize({ key: 'miPreviousEditorInGroup', comment: ['&& denotes a mnemonic'] }, "&&Previous Used Editor in Group"), 'workbench.action.openPreviousRecentlyUsedEditorInGroup');
-
-		[
-			nextEditor,
-			previousEditor,
-			__separator__(),
-			nextEditorInGroup,
-			previousEditorInGroup
-		].forEach(item => switchEditorMenu.append(item));
-
-		const switchEditor = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miSwitchEditor', comment: ['&& denotes a mnemonic'] }, "Switch &&Editor")), submenu: switchEditorMenu, enabled: true });
-
-		const switchGroupMenu = new Menu();
-
-		const focusFirstGroup = this.createMenuItem(nls.localize({ key: 'miFocusFirstGroup', comment: ['&& denotes a mnemonic'] }, "Group &&1"), 'workbench.action.focusFirstEditorGroup');
-		const focusSecondGroup = this.createMenuItem(nls.localize({ key: 'miFocusSecondGroup', comment: ['&& denotes a mnemonic'] }, "Group &&2"), 'workbench.action.focusSecondEditorGroup');
-		const focusThirdGroup = this.createMenuItem(nls.localize({ key: 'miFocusThirdGroup', comment: ['&& denotes a mnemonic'] }, "Group &&3"), 'workbench.action.focusThirdEditorGroup');
-		const focusFourthGroup = this.createMenuItem(nls.localize({ key: 'miFocusFourthGroup', comment: ['&& denotes a mnemonic'] }, "Group &&4"), 'workbench.action.focusFourthEditorGroup');
-		const focusFifthGroup = this.createMenuItem(nls.localize({ key: 'miFocusFifthGroup', comment: ['&& denotes a mnemonic'] }, "Group &&5"), 'workbench.action.focusFifthEditorGroup');
-		const nextGroup = this.createMenuItem(nls.localize({ key: 'miNextGroup', comment: ['&& denotes a mnemonic'] }, "&&Next Group"), 'workbench.action.focusNextGroup');
-		const previousGroup = this.createMenuItem(nls.localize({ key: 'miPreviousGroup', comment: ['&& denotes a mnemonic'] }, "&&Previous Group"), 'workbench.action.focusPreviousGroup');
-
-		const focusLeftGroup = this.createMenuItem(nls.localize({ key: 'miFocusLeftGroup', comment: ['&& denotes a mnemonic'] }, "Group &&Left"), 'workbench.action.focusLeftGroup');
-		const focusRightGroup = this.createMenuItem(nls.localize({ key: 'miFocusRightGroup', comment: ['&& denotes a mnemonic'] }, "Group &&Right"), 'workbench.action.focusRightGroup');
-		const focusAboveGroup = this.createMenuItem(nls.localize({ key: 'miFocusAboveGroup', comment: ['&& denotes a mnemonic'] }, "Group &&Above"), 'workbench.action.focusAboveGroup');
-		const focusBelowGroup = this.createMenuItem(nls.localize({ key: 'miFocusBelowGroup', comment: ['&& denotes a mnemonic'] }, "Group &&Below"), 'workbench.action.focusBelowGroup');
-
-		[
-			focusFirstGroup,
-			focusSecondGroup,
-			focusThirdGroup,
-			focusFourthGroup,
-			focusFifthGroup,
-			__separator__(),
-			nextGroup,
-			previousGroup,
-			__separator__(),
-			focusAboveGroup,
-			focusBelowGroup,
-			focusLeftGroup,
-			focusRightGroup
-		].forEach(item => switchGroupMenu.append(item));
-
-		const switchGroup = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miSwitchGroup', comment: ['&& denotes a mnemonic'] }, "Switch &&Group")), submenu: switchGroupMenu, enabled: true });
-
-		const gotoFile = this.createMenuItem(nls.localize({ key: 'miGotoFile', comment: ['&& denotes a mnemonic'] }, "Go to &&File..."), 'workbench.action.quickOpen');
-		const gotoSymbolInFile = this.createMenuItem(nls.localize({ key: 'miGotoSymbolInFile', comment: ['&& denotes a mnemonic'] }, "Go to &&Symbol in File..."), 'workbench.action.gotoSymbol');
-		const gotoSymbolInWorkspace = this.createMenuItem(nls.localize({ key: 'miGotoSymbolInWorkspace', comment: ['&& denotes a mnemonic'] }, "Go to Symbol in &&Workspace..."), 'workbench.action.showAllSymbols');
-		const gotoDefinition = this.createMenuItem(nls.localize({ key: 'miGotoDefinition', comment: ['&& denotes a mnemonic'] }, "Go to &&Definition"), 'editor.action.goToDeclaration');
-		const gotoTypeDefinition = this.createMenuItem(nls.localize({ key: 'miGotoTypeDefinition', comment: ['&& denotes a mnemonic'] }, "Go to &&Type Definition"), 'editor.action.goToTypeDefinition');
-		const goToImplementation = this.createMenuItem(nls.localize({ key: 'miGotoImplementation', comment: ['&& denotes a mnemonic'] }, "Go to &&Implementation"), 'editor.action.goToImplementation');
-		const gotoLine = this.createMenuItem(nls.localize({ key: 'miGotoLine', comment: ['&& denotes a mnemonic'] }, "Go to &&Line..."), 'workbench.action.gotoLine');
-
-		[
-			back,
-			forward,
-			__separator__(),
-			switchEditor,
-			switchGroup,
-			__separator__(),
-			gotoFile,
-			gotoSymbolInFile,
-			gotoSymbolInWorkspace,
-			gotoDefinition,
-			gotoTypeDefinition,
-			goToImplementation,
-			gotoLine
-		].forEach(item => gotoMenu.append(item));
-	}
-
-	private setTerminalMenu(terminalMenu: Electron.Menu): void {
-		const newTerminal = this.createMenuItem(nls.localize({ key: 'miNewTerminal', comment: ['&& denotes a mnemonic'] }, "&&New Terminal"), 'workbench.action.terminal.new');
-		const splitTerminal = this.createMenuItem(nls.localize({ key: 'miSplitTerminal', comment: ['&& denotes a mnemonic'] }, "&&Split Terminal"), 'workbench.action.terminal.split');
-
-		const runActiveFile = this.createMenuItem(nls.localize({ key: 'miRunActiveFile', comment: ['&& denotes a mnemonic'] }, "Run &&Active File"), 'workbench.action.terminal.runActiveFile');
-		const runSelectedText = this.createMenuItem(nls.localize({ key: 'miRunSelectedText', comment: ['&& denotes a mnemonic'] }, "Run &&Selected Text"), 'workbench.action.terminal.runSelectedText');
-
-		const runTask = this.createMenuItem(nls.localize({ key: 'miRunTask', comment: ['&& denotes a mnemonic'] }, "&&Run Task..."), 'workbench.action.tasks.runTask');
-		const buildTask = this.createMenuItem(nls.localize({ key: 'miBuildTask', comment: ['&& denotes a mnemonic'] }, "Run &&Build Task..."), 'workbench.action.tasks.build');
-		const showTasks = this.createMenuItem(nls.localize({ key: 'miRunningTask', comment: ['&& denotes a mnemonic'] }, "Show Runnin&&g Tasks..."), 'workbench.action.tasks.showTasks');
-		const restartTask = this.createMenuItem(nls.localize({ key: 'miRestartTask', comment: ['&& denotes a mnemonic'] }, "R&&estart Running Task..."), 'workbench.action.tasks.restartTask');
-		const terminateTask = this.createMenuItem(nls.localize({ key: 'miTerminateTask', comment: ['&& denotes a mnemonic'] }, "&&Terminate Task..."), 'workbench.action.tasks.terminate');
-		const configureTask = this.createMenuItem(nls.localize({ key: 'miConfigureTask', comment: ['&& denotes a mnemonic'] }, "&&Configure Tasks..."), 'workbench.action.tasks.configureTaskRunner');
-		const configureBuildTask = this.createMenuItem(nls.localize({ key: 'miConfigureBuildTask', comment: ['&& denotes a mnemonic'] }, "Configure De&&fault Build Task..."), 'workbench.action.tasks.configureDefaultBuildTask');
-
-		const menuItems: MenuItem[] = [
-			newTerminal,
-			splitTerminal,
-			__separator__(),
-			runTask,
-			buildTask,
-			runActiveFile,
-			runSelectedText,
-			__separator__(),
-			terminateTask,
-			restartTask,
-			showTasks,
-			__separator__(),
-			configureTask,
-			configureBuildTask
-		];
-
-		menuItems.forEach(item => terminalMenu.append(item));
-	}
-
-	private setDebugMenu(debugMenu: Electron.Menu): void {
-		const start = this.createMenuItem(nls.localize({ key: 'miStartDebugging', comment: ['&& denotes a mnemonic'] }, "&&Start Debugging"), 'workbench.action.debug.start');
-		const startWithoutDebugging = this.createMenuItem(nls.localize({ key: 'miStartWithoutDebugging', comment: ['&& denotes a mnemonic'] }, "Start &&Without Debugging"), 'workbench.action.debug.run');
-		const stop = this.createMenuItem(nls.localize({ key: 'miStopDebugging', comment: ['&& denotes a mnemonic'] }, "&&Stop Debugging"), 'workbench.action.debug.stop');
-		const restart = this.createMenuItem(nls.localize({ key: 'miRestart Debugging', comment: ['&& denotes a mnemonic'] }, "&&Restart Debugging"), 'workbench.action.debug.restart');
-
-		const openConfigurations = this.createMenuItem(nls.localize({ key: 'miOpenConfigurations', comment: ['&& denotes a mnemonic'] }, "Open &&Configurations"), 'workbench.action.debug.configure');
-		const addConfiguration = this.createMenuItem(nls.localize({ key: 'miAddConfiguration', comment: ['&& denotes a mnemonic'] }, "A&&dd Configuration..."), 'debug.addConfiguration');
-
-		const stepOver = this.createMenuItem(nls.localize({ key: 'miStepOver', comment: ['&& denotes a mnemonic'] }, "Step &&Over"), 'workbench.action.debug.stepOver');
-		const stepInto = this.createMenuItem(nls.localize({ key: 'miStepInto', comment: ['&& denotes a mnemonic'] }, "Step &&Into"), 'workbench.action.debug.stepInto');
-		const stepOut = this.createMenuItem(nls.localize({ key: 'miStepOut', comment: ['&& denotes a mnemonic'] }, "Step O&&ut"), 'workbench.action.debug.stepOut');
-		const continueAction = this.createMenuItem(nls.localize({ key: 'miContinue', comment: ['&& denotes a mnemonic'] }, "&&Continue"), 'workbench.action.debug.continue');
-
-		const toggleBreakpoint = this.createMenuItem(nls.localize({ key: 'miToggleBreakpoint', comment: ['&& denotes a mnemonic'] }, "Toggle &&Breakpoint"), 'editor.debug.action.toggleBreakpoint');
-		const breakpointsMenu = new Menu();
-		breakpointsMenu.append(this.createMenuItem(nls.localize({ key: 'miConditionalBreakpoint', comment: ['&& denotes a mnemonic'] }, "&&Conditional Breakpoint..."), 'editor.debug.action.conditionalBreakpoint'));
-		breakpointsMenu.append(this.createMenuItem(nls.localize({ key: 'miInlineBreakpoint', comment: ['&& denotes a mnemonic'] }, "Inline Breakp&&oint"), 'editor.debug.action.toggleInlineBreakpoint'));
-		breakpointsMenu.append(this.createMenuItem(nls.localize({ key: 'miFunctionBreakpoint', comment: ['&& denotes a mnemonic'] }, "&&Function Breakpoint..."), 'workbench.debug.viewlet.action.addFunctionBreakpointAction'));
-		breakpointsMenu.append(this.createMenuItem(nls.localize({ key: 'miLogPoint', comment: ['&& denotes a mnemonic'] }, "&&Logpoint..."), 'editor.debug.action.toggleLogPoint'));
-		const newBreakpoints = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miNewBreakpoint', comment: ['&& denotes a mnemonic'] }, "&&New Breakpoint")), submenu: breakpointsMenu });
-		const enableAllBreakpoints = this.createMenuItem(nls.localize({ key: 'miEnableAllBreakpoints', comment: ['&& denotes a mnemonic'] }, "&&Enable All Breakpoints"), 'workbench.debug.viewlet.action.enableAllBreakpoints');
-		const disableAllBreakpoints = this.createMenuItem(nls.localize({ key: 'miDisableAllBreakpoints', comment: ['&& denotes a mnemonic'] }, "Disable A&&ll Breakpoints"), 'workbench.debug.viewlet.action.disableAllBreakpoints');
-		const removeAllBreakpoints = this.createMenuItem(nls.localize({ key: 'miRemoveAllBreakpoints', comment: ['&& denotes a mnemonic'] }, "Remove &&All Breakpoints"), 'workbench.debug.viewlet.action.removeAllBreakpoints');
-
-		const installAdditionalDebuggers = this.createMenuItem(nls.localize({ key: 'miInstallAdditionalDebuggers', comment: ['&& denotes a mnemonic'] }, "&&Install Additional Debuggers..."), 'debug.installAdditionalDebuggers');
-		[
-			start,
-			startWithoutDebugging,
-			stop,
-			restart,
-			__separator__(),
-			openConfigurations,
-			addConfiguration,
-			__separator__(),
-			stepOver,
-			stepInto,
-			stepOut,
-			continueAction,
-			__separator__(),
-			toggleBreakpoint,
-			newBreakpoints,
-			enableAllBreakpoints,
-			disableAllBreakpoints,
-			removeAllBreakpoints,
-			__separator__(),
-			installAdditionalDebuggers
-		].forEach(item => debugMenu.append(item));
-	}
-
-	private setMacWindowMenu(macWindowMenu: Electron.Menu): void {
-		const minimize = new MenuItem({ label: nls.localize('mMinimize', "Minimize"), role: 'minimize', accelerator: 'Command+M', enabled: this.windowsMainService.getWindowCount() > 0 });
-		const zoom = new MenuItem({ label: nls.localize('mZoom', "Zoom"), role: 'zoom', enabled: this.windowsMainService.getWindowCount() > 0 });
-		const bringAllToFront = new MenuItem({ label: nls.localize('mBringToFront', "Bring All to Front"), role: 'front', enabled: this.windowsMainService.getWindowCount() > 0 });
-		const switchWindow = this.createMenuItem(nls.localize({ key: 'miSwitchWindow', comment: ['&& denotes a mnemonic'] }, "Switch &&Window..."), 'workbench.action.switchWindow');
-
-		const nativeTabMenuItems: Electron.MenuItem[] = [];
-		if (this.currentEnableNativeTabs) {
-			nativeTabMenuItems.push(__separator__());
-
-			nativeTabMenuItems.push(this.createMenuItem(nls.localize('mNewTab', "New Tab"), 'workbench.action.newWindowTab'));
-
-			nativeTabMenuItems.push(this.createRoleMenuItem(nls.localize('mShowPreviousTab', "Show Previous Tab"), 'workbench.action.showPreviousWindowTab', 'selectPreviousTab'));
-			nativeTabMenuItems.push(this.createRoleMenuItem(nls.localize('mShowNextTab', "Show Next Tab"), 'workbench.action.showNextWindowTab', 'selectNextTab'));
-			nativeTabMenuItems.push(this.createRoleMenuItem(nls.localize('mMoveTabToNewWindow', "Move Tab to New Window"), 'workbench.action.moveWindowTabToNewWindow', 'moveTabToNewWindow'));
-			nativeTabMenuItems.push(this.createRoleMenuItem(nls.localize('mMergeAllWindows', "Merge All Windows"), 'workbench.action.mergeAllWindowTabs', 'mergeAllWindows'));
-		}
-
-		[
-			minimize,
-			zoom,
-			switchWindow,
-			...nativeTabMenuItems,
-			__separator__(),
-			bringAllToFront
-		].forEach(item => macWindowMenu.append(item));
-	}
-
-	private toggleDevTools(): void {
-		const w = this.windowsMainService.getFocusedWindow();
-		if (w && w.win) {
-			const contents = w.win.webContents;
-			if (isMacintosh && w.hasHiddenTitleBarStyle() && !w.win.isFullScreen() && !contents.isDevToolsOpened()) {
-				contents.openDevTools({ mode: 'undocked' }); // due to https://github.com/electron/electron/issues/3647
-			} else {
-				contents.toggleDevTools();
-			}
-		}
-	}
-
-	private setHelpMenu(helpMenu: Electron.Menu): void {
-		const toggleDevToolsItem = new MenuItem(this.likeAction('workbench.action.toggleDevTools', {
-			label: this.mnemonicLabel(nls.localize({ key: 'miToggleDevTools', comment: ['&& denotes a mnemonic'] }, "&&Toggle Developer Tools")),
-			click: () => this.toggleDevTools(),
-			enabled: (this.windowsMainService.getWindowCount() > 0)
-		}));
-
-		const showAccessibilityOptions = new MenuItem(this.likeAction('accessibilityOptions', {
-			label: this.mnemonicLabel(nls.localize({ key: 'miAccessibilityOptions', comment: ['&& denotes a mnemonic'] }, "Accessibility &&Options")),
-			accelerator: null,
-			click: () => {
-				this.openAccessibilityOptions();
-			}
-		}, false));
-
-		const openProcessExplorer = new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miOpenProcessExplorerer', comment: ['&& denotes a mnemonic'] }, "Open &&Process Explorer")), click: () => this.runActionInRenderer('workbench.action.openProcessExplorer') });
-
-		let reportIssuesItem: Electron.MenuItem = null;
-		if (product.reportIssueUrl) {
-			const label = nls.localize({ key: 'miReportIssue', comment: ['&& denotes a mnemonic', 'Translate this to "Report Issue in English" in all languages please!'] }, "Report &&Issue");
-
-			if (this.windowsMainService.getWindowCount() > 0) {
-				reportIssuesItem = this.createMenuItem(label, 'workbench.action.openIssueReporter');
-			} else {
-				reportIssuesItem = new MenuItem({ label: this.mnemonicLabel(label), click: () => this.openUrl(product.reportIssueUrl, 'openReportIssues') });
-			}
-		}
-
-		const keyboardShortcutsUrl = isLinux ? product.keyboardShortcutsUrlLinux : isMacintosh ? product.keyboardShortcutsUrlMac : product.keyboardShortcutsUrlWin;
-		arrays.coalesce([
-			new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miWelcome', comment: ['&& denotes a mnemonic'] }, "&&Welcome")), click: () => this.runActionInRenderer('workbench.action.showWelcomePage'), enabled: (this.windowsMainService.getWindowCount() > 0) }),
-			new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miInteractivePlayground', comment: ['&& denotes a mnemonic'] }, "&&Interactive Playground")), click: () => this.runActionInRenderer('workbench.action.showInteractivePlayground'), enabled: (this.windowsMainService.getWindowCount() > 0) }),
-			product.documentationUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miDocumentation', comment: ['&& denotes a mnemonic'] }, "&&Documentation")), click: () => this.runActionInRenderer('workbench.action.openDocumentationUrl'), enabled: (this.windowsMainService.getWindowCount() > 0) }) : null,
-			product.releaseNotesUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miReleaseNotes', comment: ['&& denotes a mnemonic'] }, "&&Release Notes")), click: () => this.runActionInRenderer('update.showCurrentReleaseNotes'), enabled: (this.windowsMainService.getWindowCount() > 0) }) : null,
-			__separator__(),
-			keyboardShortcutsUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miKeyboardShortcuts', comment: ['&& denotes a mnemonic'] }, "&&Keyboard Shortcuts Reference")), click: () => this.runActionInRenderer('workbench.action.keybindingsReference'), enabled: (this.windowsMainService.getWindowCount() > 0) }) : null,
-			product.introductoryVideosUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miIntroductoryVideos', comment: ['&& denotes a mnemonic'] }, "Introductory &&Videos")), click: () => this.runActionInRenderer('workbench.action.openIntroductoryVideosUrl'), enabled: (this.windowsMainService.getWindowCount() > 0) }) : null,
-			product.tipsAndTricksUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miTipsAndTricks', comment: ['&& denotes a mnemonic'] }, "&&Tips and Tricks")), click: () => this.runActionInRenderer('workbench.action.openTipsAndTricksUrl'), enabled: (this.windowsMainService.getWindowCount() > 0) }) : null,
-			(product.introductoryVideosUrl || keyboardShortcutsUrl) ? __separator__() : null,
-			product.twitterUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miTwitter', comment: ['&& denotes a mnemonic'] }, "&&Join us on Twitter")), click: () => this.openUrl(product.twitterUrl, 'openTwitterUrl') }) : null,
-			product.requestFeatureUrl ? new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miUserVoice', comment: ['&& denotes a mnemonic'] }, "&&Search Feature Requests")), click: () => this.openUrl(product.requestFeatureUrl, 'openUserVoiceUrl') }) : null,
-			reportIssuesItem,
-			(product.twitterUrl || product.requestFeatureUrl || product.reportIssueUrl) ? __separator__() : null,
-			product.licenseUrl ? new MenuItem({
-				label: this.mnemonicLabel(nls.localize({ key: 'miLicense', comment: ['&& denotes a mnemonic'] }, "View &&License")), click: () => {
-					if (language) {
-						const queryArgChar = product.licenseUrl.indexOf('?') > 0 ? '&' : '?';
-						this.openUrl(`${product.licenseUrl}${queryArgChar}lang=${language}`, 'openLicenseUrl');
-					} else {
-						this.openUrl(product.licenseUrl, 'openLicenseUrl');
-					}
-				}
-			}) : null,
-			product.privacyStatementUrl ? new MenuItem({
-				label: this.mnemonicLabel(nls.localize({ key: 'miPrivacyStatement', comment: ['&& denotes a mnemonic'] }, "&&Privacy Statement")), click: () => {
-					if (language) {
-						const queryArgChar = product.licenseUrl.indexOf('?') > 0 ? '&' : '?';
-						this.openUrl(`${product.privacyStatementUrl}${queryArgChar}lang=${language}`, 'openPrivacyStatement');
-					} else {
-						this.openUrl(product.privacyStatementUrl, 'openPrivacyStatement');
-					}
-				}
-			}) : null,
-			(product.licenseUrl || product.privacyStatementUrl) ? __separator__() : null,
-			toggleDevToolsItem,
-			openProcessExplorer,
-			isWindows && product.quality !== 'stable' ? showAccessibilityOptions : null,
-		]).forEach(item => helpMenu.append(item));
-
-		if (!isMacintosh) {
-			const updateMenuItems = this.getUpdateMenuItems();
-			if (updateMenuItems.length) {
-				helpMenu.append(__separator__());
-				updateMenuItems.forEach(i => helpMenu.append(i));
-			}
-
-			helpMenu.append(__separator__());
-			helpMenu.append(new MenuItem({ label: this.mnemonicLabel(nls.localize({ key: 'miAbout', comment: ['&& denotes a mnemonic'] }, "&&About")), click: () => this.windowsService.openAboutDialog() }));
-		}
-	}
-
-	private openAccessibilityOptions(): void {
-		const win = new BrowserWindow({
-			alwaysOnTop: true,
-			skipTaskbar: true,
-			resizable: false,
-			width: 450,
-			height: 300,
-			show: true,
-			title: nls.localize('accessibilityOptionsWindowTitle', "Accessibility Options"),
-			webPreferences: {
-				disableBlinkFeatures: 'Auxclick'
-			}
-		});
-
-		win.setMenuBarVisibility(false);
-
-		win.loadURL('chrome://accessibility');
-	}
-
-	private getUpdateMenuItems(): Electron.MenuItem[] {
-		const state = this.updateService.state;
-
-		switch (state.type) {
-			case StateType.Uninitialized:
-				return [];
-
-			case StateType.Idle:
-				return [new MenuItem({
-					label: this.mnemonicLabel(nls.localize('miCheckForUpdates', "Check for &&Updates...")), click: () => setTimeout(() => {
-						this.reportMenuActionTelemetry('CheckForUpdate');
-
-						const focusedWindow = this.windowsMainService.getFocusedWindow();
-						const context = focusedWindow ? { windowId: focusedWindow.id } : null;
-						this.updateService.checkForUpdates(context);
-					}, 0)
-				})];
-
-			case StateType.CheckingForUpdates:
-				return [new MenuItem({ label: nls.localize('miCheckingForUpdates', "Checking For Updates..."), enabled: false })];
-
-			case StateType.AvailableForDownload:
-				return [new MenuItem({
-					label: this.mnemonicLabel(nls.localize('miDownloadUpdate', "D&&ownload Available Update")), click: () => {
-						this.updateService.downloadUpdate();
-					}
-				})];
-
-			case StateType.Downloading:
-				return [new MenuItem({ label: nls.localize('miDownloadingUpdate', "Downloading Update..."), enabled: false })];
-
-			case StateType.Downloaded:
-				return [new MenuItem({
-					label: this.mnemonicLabel(nls.localize('miInstallUpdate', "Install &&Update...")), click: () => {
-						this.reportMenuActionTelemetry('InstallUpdate');
-						this.updateService.applyUpdate();
-					}
-				})];
-
-			case StateType.Updating:
-				return [new MenuItem({ label: nls.localize('miInstallingUpdate', "Installing Update..."), enabled: false })];
-
-			case StateType.Ready:
-				return [new MenuItem({
-					label: this.mnemonicLabel(nls.localize('miRestartToUpdate', "Restart to &&Update...")), click: () => {
-						this.reportMenuActionTelemetry('RestartToUpdate');
-						this.updateService.quitAndInstall();
-					}
-				})];
-		}
-	}
-
-	private createMenuItem(label: string, commandId: string | string[], enabled?: boolean, checked?: boolean): Electron.MenuItem;
-	private createMenuItem(label: string, click: () => void, enabled?: boolean, checked?: boolean): Electron.MenuItem;
-	private createMenuItem(arg1: string, arg2: any, arg3?: boolean, arg4?: boolean): Electron.MenuItem {
-		const label = this.mnemonicLabel(arg1);
-
-		const click: () => void = (typeof arg2 === 'function') ? arg2 : (menuItem: Electron.MenuItem, win: Electron.BrowserWindow, event: Electron.Event) => {
-			let commandId = arg2;
-			if (Array.isArray(arg2)) {
-				commandId = this.isOptionClick(event) ? arg2[1] : arg2[0]; // support alternative action if we got multiple action Ids and the option key was pressed while invoking
-			}
-
-			this.runActionInRenderer(commandId);
-		};
-
-		const enabled = typeof arg3 === 'boolean' ? arg3 : this.windowsMainService.getWindowCount() > 0;
-		const checked = typeof arg4 === 'boolean' ? arg4 : false;
-
-		const options: Electron.MenuItemConstructorOptions = {
-			label,
-			click,
-			enabled
-		};
-
-		if (checked) {
-			options['type'] = 'checkbox';
-			options['checked'] = checked;
-		}
-
-		let commandId: string;
-		if (typeof arg2 === 'string') {
-			commandId = arg2;
-		} else if (Array.isArray(arg2)) {
-			commandId = arg2[0];
-		}
-
-		return new MenuItem(this.withKeybinding(commandId, options));
-	}
-
-	private createContextAwareMenuItem(label: string, commandId: string, clickHandler: IMenuItemClickHandler): Electron.MenuItem {
-		return new MenuItem(this.withKeybinding(commandId, {
-			label: this.mnemonicLabel(label),
-			enabled: this.windowsMainService.getWindowCount() > 0,
-			click: () => {
-
-				// No Active Window
-				const activeWindow = this.windowsMainService.getFocusedWindow();
-				if (!activeWindow) {
-					return clickHandler.inNoWindow();
-				}
-
-				// DevTools focused
-				if (activeWindow.win.webContents.isDevToolsFocused()) {
-					return clickHandler.inDevTools(activeWindow.win.webContents.devToolsWebContents);
-				}
-
-				// Finally execute command in Window
-				this.runActionInRenderer(commandId);
-			}
-		}));
-	}
-
-	private runActionInRenderer(id: string): void {
-		// We make sure to not run actions when the window has no focus, this helps
-		// for https://github.com/Microsoft/vscode/issues/25907 and specifically for
-		// https://github.com/Microsoft/vscode/issues/11928
-		const activeWindow = this.windowsMainService.getFocusedWindow();
-		if (activeWindow) {
-			this.windowsMainService.sendToFocused('vscode:runAction', { id, from: 'menu' } as IRunActionInWindowRequest);
-		}
-	}
-
-	private withKeybinding(commandId: string, options: Electron.MenuItemConstructorOptions): Electron.MenuItemConstructorOptions {
-		const binding = this.keybindingsResolver.getKeybinding(commandId);
-
-		// Apply binding if there is one
-		if (binding && binding.label) {
-
-			// if the binding is native, we can just apply it
-			if (binding.isNative) {
-				options.accelerator = binding.label;
-			}
-
-			// the keybinding is not native so we cannot show it as part of the accelerator of
-			// the menu item. we fallback to a different strategy so that we always display it
-			else {
-				const bindingIndex = options.label.indexOf('[');
-				if (bindingIndex >= 0) {
-					options.label = `${options.label.substr(0, bindingIndex)} [${binding.label}]`;
-				} else {
-					options.label = `${options.label} [${binding.label}]`;
-				}
-			}
-		}
-
-		// Unset bindings if there is none
-		else {
-			options.accelerator = void 0;
-		}
-
-		return options;
-	}
-
-	private likeAction(commandId: string, options: Electron.MenuItemConstructorOptions, setAccelerator = !options.accelerator): Electron.MenuItemConstructorOptions {
-		if (setAccelerator) {
-			options = this.withKeybinding(commandId, options);
-		}
-
-		const originalClick = options.click;
-		options.click = (item, window, event) => {
-			this.reportMenuActionTelemetry(commandId);
-			if (originalClick) {
-				originalClick(item, window, event);
-			}
-		};
-
-		return options;
-	}
-
-	private openUrl(url: string, id: string): void {
-		shell.openExternal(url);
-		this.reportMenuActionTelemetry(id);
-	}
-
-	private reportMenuActionTelemetry(id: string): void {
-		/* __GDPR__
-			"workbenchActionExecuted" : {
-				"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-				"from": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-			}
-		*/
-		this.telemetryService.publicLog('workbenchActionExecuted', { id, from: telemetryFrom });
-	}
-
-	private mnemonicLabel(label: string): string {
-		return baseMnemonicLabel(label, !this.currentEnableMenuBarMnemonics);
-	}
-}
-
-function __separator__(): Electron.MenuItem {
-	return new MenuItem({ type: 'separator' });
-}
diff --git a/src/vs/platform/menubar/common/menubar.ts b/src/vs/platform/menubar/common/menubar.ts
index b8983c9ab21..0e90daf9bed 100644
--- a/src/vs/platform/menubar/common/menubar.ts
+++ b/src/vs/platform/menubar/common/menubar.ts
@@ -11,13 +11,12 @@ export const IMenubarService = createDecorator<IMenubarService>('menubarService'
 export interface IMenubarService {
 	_serviceBrand: any;
 
-	updateMenubar(windowId: number, menus: IMenubarData, additionalKeybindings?: Array<IMenubarKeybinding>): TPromise<void>;
+	updateMenubar(windowId: number, menuData: IMenubarData): TPromise<void>;
 }
 
 export interface IMenubarData {
-	'Files'?: IMenubarMenu;
-	'Edit'?: IMenubarMenu;
-	[id: string]: IMenubarMenu;
+	menus: { [id: string]: IMenubarMenu };
+	keybindings: { [id: string]: IMenubarKeybinding };
 }
 
 export interface IMenubarMenu {
@@ -25,17 +24,15 @@ export interface IMenubarMenu {
 }
 
 export interface IMenubarKeybinding {
-	id: string;
 	label: string;
-	isNative: boolean;
+	isNative?: boolean; // Assumed true if missing
 }
 
 export interface IMenubarMenuItemAction {
 	id: string;
 	label: string;
-	checked: boolean;
-	enabled: boolean;
-	keybinding?: IMenubarKeybinding;
+	checked?: boolean; // Assumed false if missing
+	enabled?: boolean; // Assumed true if missing
 }
 
 export interface IMenubarMenuItemSubmenu {
@@ -54,10 +51,10 @@ export function isMenubarMenuItemSubmenu(menuItem: MenubarMenuItem): menuItem is
 	return (<IMenubarMenuItemSubmenu>menuItem).submenu !== undefined;
 }
 
-export function isMenubarMenuItemAction(menuItem: MenubarMenuItem): menuItem is IMenubarMenuItemAction {
-	return (<IMenubarMenuItemAction>menuItem).checked !== undefined || (<IMenubarMenuItemAction>menuItem).enabled !== undefined;
-}
-
 export function isMenubarMenuItemSeparator(menuItem: MenubarMenuItem): menuItem is IMenubarMenuItemSeparator {
 	return (<IMenubarMenuItemSeparator>menuItem).id === 'vscode.menubar.separator';
+}
+
+export function isMenubarMenuItemAction(menuItem: MenubarMenuItem): menuItem is IMenubarMenuItemAction {
+	return !isMenubarMenuItemSubmenu(menuItem) && !isMenubarMenuItemSeparator(menuItem);
 }
\ No newline at end of file
diff --git a/src/vs/platform/menubar/electron-main/menubar.ts b/src/vs/platform/menubar/electron-main/menubar.ts
index 840ec4d0659..af8317230f0 100644
--- a/src/vs/platform/menubar/electron-main/menubar.ts
+++ b/src/vs/platform/menubar/electron-main/menubar.ts
@@ -18,7 +18,7 @@ import { mnemonicMenuLabel as baseMnemonicLabel, unmnemonicLabel } from 'vs/base
 import { IWindowsMainService, IWindowsCountChangedEvent } from 'vs/platform/windows/electron-main/windows';
 import { IHistoryMainService } from 'vs/platform/history/common/history';
 import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
-import { IMenubarData, IMenubarKeybinding, MenubarMenuItem, isMenubarMenuItemSeparator, isMenubarMenuItemSubmenu, isMenubarMenuItemAction } from 'vs/platform/menubar/common/menubar';
+import { IMenubarData, IMenubarKeybinding, MenubarMenuItem, isMenubarMenuItemSeparator, isMenubarMenuItemSubmenu, isMenubarMenuItemAction, IMenubarMenu } from 'vs/platform/menubar/common/menubar';
 import { URI } from 'vs/base/common/uri';
 import { ILabelService } from 'vs/platform/label/common/label';
 import { IStateService } from 'vs/platform/state/common/state';
@@ -33,8 +33,7 @@ interface IMenuItemClickHandler {
 export class Menubar {
 
 	private static readonly MAX_MENU_RECENT_ENTRIES = 10;
-	private static readonly lastKnownMenubarStorageKey = 'lastKnownMenubar';
-	private static readonly lastKnownAdditionalKeybindings = 'lastKnownAdditionalKeybindings';
+	private static readonly lastKnownMenubarStorageKey = 'lastKnownMenubarData';
 
 	private isQuitting: boolean;
 	private appMenuInstalled: boolean;
@@ -47,7 +46,7 @@ export class Menubar {
 	// TODO@sbatten Remove this when fixed upstream by Electron
 	private oldMenus: Menu[];
 
-	private menubarMenus: IMenubarData;
+	private menubarMenus: { [id: string]: IMenubarMenu };
 
 	private keybindings: { [commandId: string]: IMenubarKeybinding };
 
@@ -68,9 +67,10 @@ export class Menubar {
 
 		this.menuGC = new RunOnceScheduler(() => { this.oldMenus = []; }, 10000);
 
-		this.menubarMenus = this.stateService.getItem<IMenubarData>(Menubar.lastKnownMenubarStorageKey) || Object.create(null);
+		this.menubarMenus = Object.create(null);
+		this.keybindings = Object.create(null);
 
-		this.keybindings = this.stateService.getItem<IMenubarData>(Menubar.lastKnownAdditionalKeybindings) || Object.create(null);
+		this.restoreCachedMenubarData();
 
 		this.addFallbackHandlers();
 
@@ -83,6 +83,23 @@ export class Menubar {
 		this.registerListeners();
 	}
 
+	private restoreCachedMenubarData() {
+		// TODO@sbatten remove this at some point down the road
+		const outdatedKeys = ['lastKnownAdditionalKeybindings', 'lastKnownKeybindings', 'lastKnownMenubar'];
+		outdatedKeys.forEach(key => this.stateService.removeItem(key));
+
+		const menubarData = this.stateService.getItem<IMenubarData>(Menubar.lastKnownMenubarStorageKey);
+		if (menubarData) {
+			if (menubarData.menus) {
+				this.menubarMenus = menubarData.menus;
+			}
+
+			if (menubarData.keybindings) {
+				this.keybindings = menubarData.keybindings;
+			}
+		}
+	}
+
 	private addFallbackHandlers(): void {
 		// File Menu Items
 		this.fallbackMenuHandlers['workbench.action.files.newUntitledFile'] = () => this.windowsMainService.openNewWindow(OpenContext.MENU);
@@ -167,17 +184,12 @@ export class Menubar {
 		return enableNativeTabs;
 	}
 
-	updateMenu(menus: IMenubarData, windowId: number, additionalKeybindings?: Array<IMenubarKeybinding>) {
-		this.menubarMenus = menus;
-		if (additionalKeybindings) {
-			additionalKeybindings.forEach(keybinding => {
-				this.keybindings[keybinding.id] = keybinding;
-			});
-		}
+	updateMenu(menubarData: IMenubarData, windowId: number) {
+		this.menubarMenus = menubarData.menus;
+		this.keybindings = menubarData.keybindings;
 
 		// Save off new menu and keybindings
-		this.stateService.setItem(Menubar.lastKnownMenubarStorageKey, this.menubarMenus);
-		this.stateService.setItem(Menubar.lastKnownAdditionalKeybindings, this.keybindings);
+		this.stateService.setItem(Menubar.lastKnownMenubarStorageKey, menubarData);
 
 		this.scheduleUpdateMenu();
 	}
@@ -418,13 +430,6 @@ export class Menubar {
 					this.insertCheckForUpdatesItems(menu);
 				}
 
-				// Store the keybinding
-				if (item.keybinding) {
-					this.keybindings[item.id] = item.keybinding;
-				} else if (this.keybindings[item.id]) {
-					this.keybindings[item.id] = undefined;
-				}
-
 				if (isMacintosh) {
 					if (this.windowsMainService.getWindowCount() === 0 && this.closedLastWindow) {
 						// In the fallback scenario, we are either disabled or using a fallback handler
@@ -434,10 +439,10 @@ export class Menubar {
 							menu.append(this.createMenuItem(item.label, item.id, false, item.checked));
 						}
 					} else {
-						menu.append(this.createMenuItem(item.label, item.id, item.enabled, item.checked));
+						menu.append(this.createMenuItem(item.label, item.id, item.enabled === false ? false : true, !!item.checked));
 					}
 				} else {
-					menu.append(this.createMenuItem(item.label, item.id, item.enabled, item.checked));
+					menu.append(this.createMenuItem(item.label, item.id, item.enabled === false ? false : true, !!item.checked));
 				}
 			}
 		});
@@ -706,7 +711,7 @@ export class Menubar {
 		if (binding && binding.label) {
 
 			// if the binding is native, we can just apply it
-			if (binding.isNative) {
+			if (binding.isNative !== false) {
 				options.accelerator = binding.label;
 			}
 
diff --git a/src/vs/platform/menubar/electron-main/menubarService.ts b/src/vs/platform/menubar/electron-main/menubarService.ts
index 79554f380b6..0104bbe23e8 100644
--- a/src/vs/platform/menubar/electron-main/menubarService.ts
+++ b/src/vs/platform/menubar/electron-main/menubarService.ts
@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IMenubarService, IMenubarData, IMenubarKeybinding } from 'vs/platform/menubar/common/menubar';
+import { IMenubarService, IMenubarData } from 'vs/platform/menubar/common/menubar';
 import { Menubar } from 'vs/platform/menubar/electron-main/menubar';
 import { ILogService } from 'vs/platform/log/common/log';
 import { TPromise } from 'vs/base/common/winjs.base';
@@ -22,11 +22,11 @@ export class MenubarService implements IMenubarService {
 		this._menubar = this.instantiationService.createInstance(Menubar);
 	}
 
-	updateMenubar(windowId: number, menus: IMenubarData, additionalKeybindings?: Array<IMenubarKeybinding>): TPromise<void> {
+	updateMenubar(windowId: number, menus: IMenubarData): TPromise<void> {
 		this.logService.trace('menubarService#updateMenubar', windowId);
 
 		if (this._menubar) {
-			this._menubar.updateMenu(menus, windowId, additionalKeybindings);
+			this._menubar.updateMenu(menus, windowId);
 		}
 
 		return TPromise.as(null);
diff --git a/src/vs/platform/menubar/node/menubarIpc.ts b/src/vs/platform/menubar/node/menubarIpc.ts
index 4474fdf5a19..52eaa99666b 100644
--- a/src/vs/platform/menubar/node/menubarIpc.ts
+++ b/src/vs/platform/menubar/node/menubarIpc.ts
@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 import { IChannel } from 'vs/base/parts/ipc/node/ipc';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IMenubarService, IMenubarData, IMenubarKeybinding } from 'vs/platform/menubar/common/menubar';
+import { IMenubarService, IMenubarData } from 'vs/platform/menubar/common/menubar';
 import { Event } from 'vs/base/common/event';
 
 export interface IMenubarChannel extends IChannel {
@@ -22,7 +22,7 @@ export class MenubarChannel implements IMenubarChannel {
 
 	call(command: string, arg?: any): TPromise<any> {
 		switch (command) {
-			case 'updateMenubar': return this.service.updateMenubar(arg[0], arg[1], arg[2]);
+			case 'updateMenubar': return this.service.updateMenubar(arg[0], arg[1]);
 		}
 		return undefined;
 	}
@@ -34,7 +34,7 @@ export class MenubarChannelClient implements IMenubarService {
 
 	constructor(private channel: IMenubarChannel) { }
 
-	updateMenubar(windowId: number, menus: IMenubarData, additionalKeybindings?: Array<IMenubarKeybinding>): TPromise<void> {
-		return this.channel.call('updateMenubar', [windowId, menus, additionalKeybindings]);
+	updateMenubar(windowId: number, menuData: IMenubarData): TPromise<void> {
+		return this.channel.call('updateMenubar', [windowId, menuData]);
 	}
 }
\ No newline at end of file
diff --git a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
index edaa6ace6c1..492d1ef3b3f 100644
--- a/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
+++ b/src/vs/workbench/browser/parts/titlebar/menubarControl.ts
@@ -463,9 +463,9 @@ export class MenubarControl extends Disposable {
 			this.setupCustomMenubar();
 		} else {
 			// Send menus to main process to be rendered by Electron
-			const menubarData = {};
+			const menubarData = { menus: {}, keybindings: {} };
 			if (this.getMenubarMenus(menubarData)) {
-				this.menubarService.updateMenubar(this.windowService.getCurrentWindowId(), menubarData, this.getAdditionalKeybindings());
+				this.menubarService.updateMenubar(this.windowService.getCurrentWindowId(), menubarData);
 			}
 		}
 	}
@@ -923,25 +923,25 @@ export class MenubarControl extends Disposable {
 	private getMenubarKeybinding(id: string): IMenubarKeybinding {
 		const binding = this.keybindingService.lookupKeybinding(id);
 		if (!binding) {
-			return null;
+			return undefined;
 		}
 
 		// first try to resolve a native accelerator
 		const electronAccelerator = binding.getElectronAccelerator();
 		if (electronAccelerator) {
-			return { id, label: electronAccelerator, isNative: true };
+			return { label: electronAccelerator };
 		}
 
 		// we need this fallback to support keybindings that cannot show in electron menus (e.g. chords)
 		const acceleratorLabel = binding.getLabel();
 		if (acceleratorLabel) {
-			return { id, label: acceleratorLabel, isNative: false };
+			return { label: acceleratorLabel, isNative: false };
 		}
 
 		return null;
 	}
 
-	private populateMenuItems(menu: IMenu, menuToPopulate: IMenubarMenu) {
+	private populateMenuItems(menu: IMenu, menuToPopulate: IMenubarMenu, keybindings: { [id: string]: IMenubarKeybinding }) {
 		let groups = menu.getActions();
 		for (let group of groups) {
 			const [, actions] = group;
@@ -950,7 +950,7 @@ export class MenubarControl extends Disposable {
 
 				if (menuItem instanceof SubmenuItemAction) {
 					const submenu = { items: [] };
-					this.populateMenuItems(this.menuService.createMenu(menuItem.item.submenu, this.contextKeyService), submenu);
+					this.populateMenuItems(this.menuService.createMenu(menuItem.item.submenu, this.contextKeyService), submenu, keybindings);
 
 					let menubarSubmenuItem: IMenubarMenuItemSubmenu = {
 						id: menuItem.id,
@@ -962,13 +962,19 @@ export class MenubarControl extends Disposable {
 				} else {
 					let menubarMenuItem: IMenubarMenuItemAction = {
 						id: menuItem.id,
-						label: menuItem.label,
-						checked: menuItem.checked,
-						enabled: menuItem.enabled,
-						keybinding: this.getMenubarKeybinding(menuItem.id)
+						label: menuItem.label
 					};
 
+					if (menuItem.checked) {
+						menubarMenuItem.checked = true;
+					}
+
+					if (!menuItem.enabled) {
+						menubarMenuItem.enabled = false;
+					}
+
 					menubarMenuItem.label = this.calculateActionLabel(menubarMenuItem);
+					keybindings[menuItem.id] = this.getMenubarKeybinding(menuItem.id);
 					menuToPopulate.items.push(menubarMenuItem);
 				}
 			});
@@ -981,10 +987,10 @@ export class MenubarControl extends Disposable {
 		}
 	}
 
-	private getAdditionalKeybindings(): Array<IMenubarKeybinding> {
-		const keybindings = [];
+	private getAdditionalKeybindings(): { [id: string]: IMenubarKeybinding } {
+		const keybindings = {};
 		if (isMacintosh) {
-			keybindings.push(this.getMenubarKeybinding('workbench.action.quit'));
+			keybindings['workbench.action.quit'] = (this.getMenubarKeybinding('workbench.action.quit'));
 		}
 
 		return keybindings;
@@ -995,15 +1001,16 @@ export class MenubarControl extends Disposable {
 			return false;
 		}
 
+		menubarData.keybindings = this.getAdditionalKeybindings();
 		for (let topLevelMenuName of Object.keys(this.topLevelMenus)) {
 			const menu = this.topLevelMenus[topLevelMenuName];
 			let menubarMenu: IMenubarMenu = { items: [] };
-			this.populateMenuItems(menu, menubarMenu);
+			this.populateMenuItems(menu, menubarMenu, menubarData.keybindings);
 			if (menubarMenu.items.length === 0) {
 				// Menus are incomplete
 				return false;
 			}
-			menubarData[topLevelMenuName] = menubarMenu;
+			menubarData.menus[topLevelMenuName] = menubarMenu;
 		}
 
 		return true;

From bab47f0ffde4692b5a738c915bd823ef7ebc8d39 Mon Sep 17 00:00:00 2001
From: SteVen Batten <stbatt@microsoft.com>
Date: Tue, 9 Oct 2018 10:53:25 -0700
Subject: [PATCH 70/76] add select all role for macOS fixes #19003

---
 src/vs/platform/menubar/electron-main/menubar.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/vs/platform/menubar/electron-main/menubar.ts b/src/vs/platform/menubar/electron-main/menubar.ts
index af8317230f0..e0912eb4cce 100644
--- a/src/vs/platform/menubar/electron-main/menubar.ts
+++ b/src/vs/platform/menubar/electron-main/menubar.ts
@@ -652,6 +652,8 @@ export class Menubar {
 				options['role'] = 'copy';
 			} else if (commandId === 'editor.action.clipboardPasteAction') {
 				options['role'] = 'paste';
+			} else if (commandId === 'editor.action.selectAll') {
+				options['role'] = 'selectAll';
 			}
 
 			// Add context aware click handlers for special case menu items

From 797161bd324200dcaf1cf297998a92b84c70ea9d Mon Sep 17 00:00:00 2001
From: Daniel Imms <daimms@microsoft.com>
Date: Tue, 9 Oct 2018 11:51:15 -0700
Subject: [PATCH 71/76] vscode-xterm@3.9.0-beta5

Fixes #60310
---
 package.json | 2 +-
 yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package.json b/package.json
index bb9cb6ae938..0c9f3ed70d5 100644
--- a/package.json
+++ b/package.json
@@ -49,7 +49,7 @@
     "vscode-nsfw": "1.0.17",
     "vscode-ripgrep": "^1.2.2",
     "vscode-textmate": "^4.0.1",
-    "vscode-xterm": "3.9.0-beta3",
+    "vscode-xterm": "3.9.0-beta5",
     "winreg": "^1.2.4",
     "yauzl": "^2.9.1",
     "yazl": "^2.4.3"
diff --git a/yarn.lock b/yarn.lock
index 0f8b03139fc..e75d9403db5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9351,10 +9351,10 @@ vscode-textmate@^4.0.1:
   dependencies:
     oniguruma "^7.0.0"
 
-vscode-xterm@3.9.0-beta3:
-  version "3.9.0-beta3"
-  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta3.tgz#2a76fb9320971c17a0d4c2a5fe53e34692dff45d"
-  integrity sha512-CZpzmqSonz3f57XCaXE07m6lVvbkXlLq+knlDyYTmxBTrlIloY3Oe/YJszDfusJnq0F+xc8NAyuG3xisg6x7yw==
+vscode-xterm@3.9.0-beta5:
+  version "3.9.0-beta5"
+  resolved "https://registry.yarnpkg.com/vscode-xterm/-/vscode-xterm-3.9.0-beta5.tgz#3730966ed586632f40883852252333744ba5b9b7"
+  integrity sha512-MWLnQieNviCsvuV8He93N2usI2FXBGeUyNzIQNO7HsxjgIhn4zEwg3e2aSeQAAABeEkqLec5hp4vHpcqdPGU7Q==
 
 vso-node-api@6.1.2-preview:
   version "6.1.2-preview"

From 2d0dd21a4a5b6479901b8faceb5820ae1ef0eb28 Mon Sep 17 00:00:00 2001
From: Matt Bierner <matb@microsoft.com>
Date: Tue, 9 Oct 2018 17:06:21 -0700
Subject: [PATCH 72/76] Pick up TS 3.1.2

---
 extensions/package.json | 2 +-
 extensions/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/extensions/package.json b/extensions/package.json
index d75f31424f4..5d1eaf63e22 100644
--- a/extensions/package.json
+++ b/extensions/package.json
@@ -3,7 +3,7 @@
   "version": "0.0.1",
   "description": "Dependencies shared by all extensions",
   "dependencies": {
-    "typescript": "3.1.1"
+    "typescript": "3.1.2"
   },
   "scripts": {
     "postinstall": "node ./postinstall"
diff --git a/extensions/yarn.lock b/extensions/yarn.lock
index 4beb25d35fc..fa9bc190628 100644
--- a/extensions/yarn.lock
+++ b/extensions/yarn.lock
@@ -2,7 +2,7 @@
 # yarn lockfile v1
 
 
-typescript@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.1.1.tgz#3362ba9dd1e482ebb2355b02dfe8bcd19a2c7c96"
-  integrity sha512-Veu0w4dTc/9wlWNf2jeRInNodKlcdLgemvPsrNpfu5Pq39sgfFjvIIgTsvUHCoLBnMhPoUA+tFxsXjU6VexVRQ==
+typescript@3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.1.2.tgz#c03a5d16f30bb60ad8bb6fe8e7cb212eedeec950"
+  integrity sha512-gOoGJWbNnFAfP9FlrSV63LYD5DJqYJHG5ky1kOXSl3pCImn4rqWy/flyq1BRd4iChQsoCqjbQaqtmXO4yCVPCA==

From 25179088b188a3fa799ac99b70e2f95d1e411d9f Mon Sep 17 00:00:00 2001
From: Rob Lourens <roblourens@gmail.com>
Date: Tue, 9 Oct 2018 15:23:19 -0700
Subject: [PATCH 73/76] Fix search result bubbles showing in the wrong place in
 wide mode

---
 src/vs/workbench/parts/search/browser/searchView.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/vs/workbench/parts/search/browser/searchView.ts b/src/vs/workbench/parts/search/browser/searchView.ts
index de7679300bc..d8b78ed9fe8 100644
--- a/src/vs/workbench/parts/search/browser/searchView.ts
+++ b/src/vs/workbench/parts/search/browser/searchView.ts
@@ -175,9 +175,9 @@ export class SearchView extends Viewlet implements IViewlet, IPanel {
 		super.create(parent);
 
 		this.viewModel = this._register(this.searchWorkbenchService.searchModel);
-		const containerElement = dom.append(parent, $('.search-view'));
+		dom.addClass(parent, 'search-view');
 
-		this.searchWidgetsContainerElement = dom.append(containerElement, $('.search-widgets-container'));
+		this.searchWidgetsContainerElement = dom.append(parent, $('.search-widgets-container'));
 		this.createSearchWidget(this.searchWidgetsContainerElement);
 
 		const history = this.searchHistoryService.load();
@@ -254,12 +254,12 @@ export class SearchView extends Viewlet implements IViewlet, IPanel {
 		this.inputPatternExcludes.onCancel(() => this.viewModel.cancelSearch()); // Cancel search without focusing the search widget
 		this.trackInputBox(this.inputPatternExcludes.inputFocusTracker, this.inputPatternExclusionsFocused);
 
-		this.messagesElement = dom.append(containerElement, $('.messages'));
+		this.messagesElement = dom.append(parent, $('.messages'));
 		if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
 			this.showSearchWithoutFolderMessage();
 		}
 
-		this.createSearchResultsView(containerElement);
+		this.createSearchResultsView(parent);
 
 		this.actions = [
 			this.instantiationService.createInstance(RefreshAction, RefreshAction.ID, RefreshAction.LABEL),

From c4494cc1bef31735fdbf39ba74c85ba810f49639 Mon Sep 17 00:00:00 2001
From: Rob Lourens <roblourens@gmail.com>
Date: Tue, 9 Oct 2018 15:24:11 -0700
Subject: [PATCH 74/76] Much faster parsing of long lines/multiline matches
 from ripgrep

---
 .../services/search/node/ripgrepTextSearch.ts | 39 ++++++++++++-------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/src/vs/workbench/services/search/node/ripgrepTextSearch.ts b/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
index 7f394acb393..50729fae045 100644
--- a/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
+++ b/src/vs/workbench/services/search/node/ripgrepTextSearch.ts
@@ -185,7 +185,7 @@ export function rgErrorMsgForDisplay(msg: string): string | undefined {
 
 export class RipgrepParser extends EventEmitter {
 	private fileMatch: FileMatch;
-	private remainder: string;
+	private remainder = '';
 	private isDone: boolean;
 	private stringDecoder: NodeStringDecoder;
 
@@ -209,30 +209,41 @@ export class RipgrepParser extends EventEmitter {
 	}
 
 	public handleData(data: Buffer | string): void {
+		if (this.isDone) {
+			return;
+		}
+
 		const dataStr = typeof data === 'string' ? data : this.stringDecoder.write(data);
 		this.handleDecodedData(dataStr);
 	}
 
 	private handleDecodedData(decodedData: string): void {
+		// check for newline before appending to remainder
+		let newlineIdx = decodedData.indexOf('\n');
+
 		// If the previous data chunk didn't end in a newline, prepend it to this chunk
-		const dataStr = this.remainder ?
-			this.remainder + decodedData :
-			decodedData;
+		const dataStr = this.remainder + decodedData;
 
-		const dataLines: string[] = dataStr.split(/\r\n|\n/);
-		this.remainder = dataLines[dataLines.length - 1] ? dataLines.pop() : null;
-
-		for (let l = 0; l < dataLines.length; l++) {
-			const outputLine = dataLines[l].trim();
-
-			if (outputLine) {
-				this.handleLine(outputLine);
-			}
+		if (newlineIdx >= 0) {
+			newlineIdx += this.remainder.length;
+		} else {
+			// Shortcut
+			this.remainder = dataStr;
+			return;
 		}
+
+		let prevIdx = 0;
+		while (newlineIdx >= 0) {
+			this.handleLine(dataStr.substring(prevIdx, newlineIdx).trim());
+			prevIdx = newlineIdx + 1;
+			newlineIdx = dataStr.indexOf('\n', prevIdx);
+		}
+
+		this.remainder = dataStr.substring(prevIdx).trim();
 	}
 
 	private handleLine(outputLine: string): void {
-		if (this.isDone) {
+		if (this.isDone || !outputLine) {
 			return;
 		}
 

From f3f7d97129cabb8279a03860f3110875b45f337b Mon Sep 17 00:00:00 2001
From: Rob Lourens <roblourens@gmail.com>
Date: Tue, 9 Oct 2018 18:31:19 -0700
Subject: [PATCH 75/76] Fix some search tree display issues with action bar and
 count badge

---
 .../parts/search/browser/media/searchview.css | 34 ++++++-------------
 .../parts/search/browser/searchResultsView.ts |  3 +-
 2 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/src/vs/workbench/parts/search/browser/media/searchview.css b/src/vs/workbench/parts/search/browser/media/searchview.css
index 6cde24133a4..ea4f2d08353 100644
--- a/src/vs/workbench/parts/search/browser/media/searchview.css
+++ b/src/vs/workbench/parts/search/browser/media/searchview.css
@@ -210,7 +210,6 @@
 }
 
 .search-view .linematch > .match {
-	flex: 1;
 	overflow: hidden;
 	text-overflow: ellipsis;
 }
@@ -233,15 +232,13 @@
 	margin: 0;
 }
 
-.search-view .monaco-tree .monaco-tree-row.focused .monaco-action-bar {
-	width: 0; /* in order to support a11y with keyboard, we use width: 0 to hide the actions, which still allows to "Tab" into the actions */
-	display: block;
-}
-
 .search-view .monaco-tree .monaco-tree-row:hover:not(.highlighted) .monaco-action-bar,
 .search-view .monaco-tree .monaco-tree-row.focused .monaco-action-bar {
-	width: inherit;
-	display: block;
+	display: inline-block;
+}
+
+.search-view:not(.wide) .monaco-tree .monaco-tree-row .linematch .actionBarContainer {
+	flex: 1;
 }
 
 .search-view .monaco-tree .monaco-tree-row .monaco-action-bar .action-label {
@@ -287,24 +284,15 @@
 	margin-right: 12px;
 }
 
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row:hover .content .filematch .monaco-count-badge,
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row:hover .content .foldermatch .monaco-count-badge,
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row:hover .content .linematch .monaco-count-badge,
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row.focused .content .filematch .monaco-count-badge,
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row.focused .content .foldermatch .monaco-count-badge,
-.search-view:not(.wide) > .results > .monaco-tree .monaco-tree-row.focused .content .linematch .monaco-count-badge {
+.search-view > .results > .monaco-tree .monaco-tree-row:hover .content .filematch .monaco-count-badge,
+.search-view > .results > .monaco-tree .monaco-tree-row:hover .content .foldermatch .monaco-count-badge,
+.search-view > .results > .monaco-tree .monaco-tree-row:hover .content .linematch .monaco-count-badge,
+.search-view > .results > .monaco-tree .monaco-tree-row.focused .content .filematch .monaco-count-badge,
+.search-view > .results > .monaco-tree .monaco-tree-row.focused .content .foldermatch .monaco-count-badge,
+.search-view > .results > .monaco-tree .monaco-tree-row.focused .content .linematch .monaco-count-badge {
 	display: none;
 }
 
-.search-view.wide > .results > .monaco-tree .monaco-tree-row:hover .content .filematch .badge,
-.search-view.wide > .results > .monaco-tree .monaco-tree-row:hover .content .foldermatch .badge,
-.search-view.wide > .results > .monaco-tree .monaco-tree-row:hover .content .linematch .badge,
-.search-view.wide > .results > .monaco-tree .monaco-tree-row.focused .content .filematch .badge,
-.search-view.wide > .results > .monaco-tree .monaco-tree-row.focused .content .foldermatch .badge,
-.search-view.wide > .results > .monaco-tree .monaco-tree-row.focused .content .linematch .badge {
-	flex: 1;
-}
-
 .search-view .focused .monaco-tree-row.selected:not(.highlighted) > .content.actions .action-remove,
 .vs-dark .monaco-workbench .search-view .focused .monaco-tree-row.selected:not(.highlighted) > .content.actions .action-remove {
 	background: url("action-remove-focus.svg") center center no-repeat;
diff --git a/src/vs/workbench/parts/search/browser/searchResultsView.ts b/src/vs/workbench/parts/search/browser/searchResultsView.ts
index 9d7d288442a..d430182da43 100644
--- a/src/vs/workbench/parts/search/browser/searchResultsView.ts
+++ b/src/vs/workbench/parts/search/browser/searchResultsView.ts
@@ -233,7 +233,8 @@ export class SearchRenderer extends Disposable implements IRenderer {
 		const match = DOM.append(parent, DOM.$('span.findInFileMatch'));
 		const replace = DOM.append(parent, DOM.$('span.replaceMatch'));
 		const after = DOM.append(parent, DOM.$('span'));
-		const actions = new ActionBar(container, { animated: false });
+		const actionBarContainer = DOM.append(container, DOM.$('span.actionBarContainer'));
+		const actions = new ActionBar(actionBarContainer, { animated: false });
 
 		return {
 			parent,

From cc5e2b41c3add18a31e87f84b5d6162566a38d6e Mon Sep 17 00:00:00 2001
From: Rob Lourens <roblourens@gmail.com>
Date: Tue, 9 Oct 2018 20:27:48 -0700
Subject: [PATCH 76/76] Multiline match hint UI for #13155. Implement
 search.showLineNumbers to fix #39219

---
 src/vs/platform/search/common/search.ts       |  1 +
 .../parts/search/browser/media/searchview.css | 16 +++++
 .../parts/search/browser/searchResultsView.ts | 69 +++++++++++++------
 .../parts/search/browser/searchView.ts        |  2 +-
 .../electron-browser/search.contribution.ts   |  5 ++
 5 files changed, 72 insertions(+), 21 deletions(-)

diff --git a/src/vs/platform/search/common/search.ts b/src/vs/platform/search/common/search.ts
index 7b8abda484d..8b4bde818b0 100644
--- a/src/vs/platform/search/common/search.ts
+++ b/src/vs/platform/search/common/search.ts
@@ -296,6 +296,7 @@ export interface ISearchConfigurationProperties {
 	globalFindClipboard: boolean;
 	location: 'sidebar' | 'panel';
 	useReplacePreview: boolean;
+	showLineNumbers: boolean;
 }
 
 export interface ISearchConfiguration extends IFilesConfiguration {
diff --git a/src/vs/workbench/parts/search/browser/media/searchview.css b/src/vs/workbench/parts/search/browser/media/searchview.css
index ea4f2d08353..f7c854b53cd 100644
--- a/src/vs/workbench/parts/search/browser/media/searchview.css
+++ b/src/vs/workbench/parts/search/browser/media/searchview.css
@@ -214,6 +214,18 @@
 	text-overflow: ellipsis;
 }
 
+.search-view .linematch .matchLineNum {
+	margin-left: 7px;
+	margin-right: 4px;
+	opacity: .7;
+	font-size: 0.9em;
+	display: none;
+}
+
+.search-view .linematch .matchLineNum.show {
+	display: block;
+}
+
 .search-view .linematch.changedOrRemoved {
 	font-style: italic;
 }
@@ -241,6 +253,10 @@
 	flex: 1;
 }
 
+.search-view:not(.wide) .monaco-tree .monaco-tree-row .monaco-action-bar {
+	float: right;
+}
+
 .search-view .monaco-tree .monaco-tree-row .monaco-action-bar .action-label {
 	margin-right: 0.2em;
 	margin-top: 4px;
diff --git a/src/vs/workbench/parts/search/browser/searchResultsView.ts b/src/vs/workbench/parts/search/browser/searchResultsView.ts
index d430182da43..28982417ce1 100644
--- a/src/vs/workbench/parts/search/browser/searchResultsView.ts
+++ b/src/vs/workbench/parts/search/browser/searchResultsView.ts
@@ -3,31 +3,32 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as nls from 'vs/nls';
-import * as resources from 'vs/base/common/resources';
-import * as paths from 'vs/base/common/paths';
 import * as DOM from 'vs/base/browser/dom';
-import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
-import { TPromise } from 'vs/base/common/winjs.base';
-import { IAction, IActionRunner } from 'vs/base/common/actions';
 import { ActionBar } from 'vs/base/browser/ui/actionbar/actionbar';
 import { CountBadge } from 'vs/base/browser/ui/countBadge/countBadge';
-import { FileLabel } from 'vs/workbench/browser/labels';
-import { ITree, IDataSource, IAccessibilityProvider, IFilter, IRenderer, ContextMenuEvent, ISorter } from 'vs/base/parts/tree/browser/tree';
-import { Match, SearchResult, FileMatch, FileMatchOrMatch, SearchModel, FolderMatch, searchMatchComparer, RenderableMatch } from 'vs/workbench/parts/search/common/searchModel';
-import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
-import { SearchView } from 'vs/workbench/parts/search/browser/searchView';
-import { RemoveAction, ReplaceAllAction, ReplaceAction, ReplaceAllInFolderAction } from 'vs/workbench/parts/search/browser/searchActions';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { attachBadgeStyler } from 'vs/platform/theme/common/styler';
-import { IThemeService } from 'vs/platform/theme/common/themeService';
-import { FileKind } from 'vs/platform/files/common/files';
+import { IAction } from 'vs/base/common/actions';
+import { Disposable, dispose, IDisposable } from 'vs/base/common/lifecycle';
+import * as paths from 'vs/base/common/paths';
+import * as resources from 'vs/base/common/resources';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { ContextMenuEvent, IAccessibilityProvider, IDataSource, IFilter, IRenderer, ISorter, ITree } from 'vs/base/parts/tree/browser/tree';
+import * as nls from 'vs/nls';
+import { fillInContextMenuActions } from 'vs/platform/actions/browser/menuItemActionItem';
+import { IMenu, IMenuService, MenuId } from 'vs/platform/actions/common/actions';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
-import { IMenuService, MenuId, IMenu } from 'vs/platform/actions/common/actions';
-import { WorkbenchTreeController, WorkbenchTree } from 'vs/platform/list/browser/listService';
-import { fillInContextMenuActions } from 'vs/platform/actions/browser/menuItemActionItem';
+import { FileKind } from 'vs/platform/files/common/files';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILabelService } from 'vs/platform/label/common/label';
+import { WorkbenchTree, WorkbenchTreeController } from 'vs/platform/list/browser/listService';
+import { ISearchConfigurationProperties } from 'vs/platform/search/common/search';
+import { attachBadgeStyler } from 'vs/platform/theme/common/styler';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
+import { FileLabel } from 'vs/workbench/browser/labels';
+import { RemoveAction, ReplaceAction, ReplaceAllAction, ReplaceAllInFolderAction } from 'vs/workbench/parts/search/browser/searchActions';
+import { SearchView } from 'vs/workbench/parts/search/browser/searchView';
+import { FileMatch, FileMatchOrMatch, FolderMatch, Match, RenderableMatch, searchMatchComparer, SearchModel, SearchResult } from 'vs/workbench/parts/search/common/searchModel';
 
 export class SearchDataSource implements IDataSource {
 
@@ -147,6 +148,7 @@ interface IMatchTemplate {
 	match: HTMLElement;
 	replace: HTMLElement;
 	after: HTMLElement;
+	lineNumber: HTMLElement;
 	actions: ActionBar;
 }
 
@@ -157,10 +159,10 @@ export class SearchRenderer extends Disposable implements IRenderer {
 	private static readonly MATCH_TEMPLATE_ID = 'match';
 
 	constructor(
-		actionRunner: IActionRunner,
 		private searchView: SearchView,
 		@IInstantiationService private instantiationService: IInstantiationService,
 		@IThemeService private themeService: IThemeService,
+		@IConfigurationService private configurationService: IConfigurationService,
 		@IWorkspaceContextService protected contextService: IWorkspaceContextService
 	) {
 		super();
@@ -233,6 +235,7 @@ export class SearchRenderer extends Disposable implements IRenderer {
 		const match = DOM.append(parent, DOM.$('span.findInFileMatch'));
 		const replace = DOM.append(parent, DOM.$('span.replaceMatch'));
 		const after = DOM.append(parent, DOM.$('span'));
+		const lineNumber = DOM.append(container, DOM.$('span.matchLineNum'));
 		const actionBarContainer = DOM.append(container, DOM.$('span.actionBarContainer'));
 		const actions = new ActionBar(actionBarContainer, { animated: false });
 
@@ -242,6 +245,7 @@ export class SearchRenderer extends Disposable implements IRenderer {
 			match,
 			replace,
 			after,
+			lineNumber,
 			actions
 		};
 	}
@@ -303,6 +307,16 @@ export class SearchRenderer extends Disposable implements IRenderer {
 		templateData.after.textContent = preview.after;
 		templateData.parent.title = (preview.before + (replace ? match.replaceString : preview.inside) + preview.after).trim().substr(0, 999);
 
+		const numLines = match.range().endLineNumber - match.range().startLineNumber;
+		const extraLinesStr = numLines > 0 ? `+${numLines}` : '';
+
+		const showLineNumbers = this.configurationService.getValue<ISearchConfigurationProperties>('search').showLineNumbers;
+		const lineNumberStr = showLineNumbers ? `:${match.range().startLineNumber}` : '';
+		DOM.toggleClass(templateData.lineNumber, 'show', (numLines > 0) || showLineNumbers);
+
+		templateData.lineNumber.textContent = lineNumberStr + extraLinesStr;
+		templateData.lineNumber.setAttribute('title', this.getMatchTitle(match, showLineNumbers));
+
 		templateData.actions.clear();
 		if (searchModel.isReplaceActive()) {
 			templateData.actions.push([this.instantiationService.createInstance(ReplaceAction, tree, match, this.searchView), new RemoveAction(tree, match)], { icon: true, label: false });
@@ -311,6 +325,21 @@ export class SearchRenderer extends Disposable implements IRenderer {
 		}
 	}
 
+	private getMatchTitle(match: Match, showLineNumbers: boolean): string {
+		const startLine = match.range().startLineNumber;
+		const numLines = match.range().endLineNumber - match.range().startLineNumber;
+
+		const lineNumStr = showLineNumbers ?
+			nls.localize('lineNumStr', "From line {0}", startLine, numLines) + ' ' :
+			'';
+
+		const numLinesStr = numLines > 0 ?
+			'+ ' + nls.localize('numLinesStr', "{0} more lines", numLines) :
+			'';
+
+		return lineNumStr + numLinesStr;
+	}
+
 	public disposeTemplate(tree: ITree, templateId: string, templateData: any): void {
 		if (SearchRenderer.FOLDER_MATCH_TEMPLATE_ID === templateId) {
 			const template = <IFolderMatchTemplate>templateData;
diff --git a/src/vs/workbench/parts/search/browser/searchView.ts b/src/vs/workbench/parts/search/browser/searchView.ts
index d8b78ed9fe8..1efd9fc31aa 100644
--- a/src/vs/workbench/parts/search/browser/searchView.ts
+++ b/src/vs/workbench/parts/search/browser/searchView.ts
@@ -518,7 +518,7 @@ export class SearchView extends Viewlet implements IViewlet, IPanel {
 	private createSearchResultsView(container: HTMLElement): void {
 		this.resultsElement = dom.append(container, $('.results.show-file-icons'));
 		const dataSource = this._register(this.instantiationService.createInstance(SearchDataSource));
-		const renderer = this._register(this.instantiationService.createInstance(SearchRenderer, this.getActionRunner(), this));
+		const renderer = this._register(this.instantiationService.createInstance(SearchRenderer, this));
 		const dnd = this.instantiationService.createInstance(SimpleFileResourceDragAndDrop, (obj: any) => obj instanceof FileMatch ? obj.resource() : void 0);
 
 		this.tree = this._register(this.instantiationService.createInstance(WorkbenchTree, this.resultsElement, {
diff --git a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
index cacb5c850b3..25018f00ecb 100644
--- a/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
+++ b/src/vs/workbench/parts/search/electron-browser/search.contribution.ts
@@ -648,6 +648,11 @@ configurationRegistry.registerConfiguration({
 			type: 'boolean',
 			default: true,
 			description: nls.localize('search.useReplacePreview', "Controls whether to open Replace Preview when selecting or replacing a match."),
+		},
+		'search.showLineNumbers': {
+			type: 'boolean',
+			default: false,
+			description: nls.localize('search.showLineNumbers', "Controls whether to show line numbers for search results."),
 		}
 	}
 });