Merge VS Code 1.21 source code (#1067)

* Initial VS Code 1.21 file copy with patches

* A few more merges

* Post npm install

* Fix batch of build breaks

* Fix more build breaks

* Fix more build errors

* Fix more build breaks

* Runtime fixes 1

* Get connection dialog working with some todos

* Fix a few packaging issues

* Copy several node_modules to package build to fix loader issues

* Fix breaks from master

* A few more fixes

* Make tests pass

* First pass of license header updates

* Second pass of license header updates

* Fix restore dialog issues

* Remove add additional themes menu items

* fix select box issues where the list doesn't show up

* formatting

* Fix editor dispose issue

* Copy over node modules to correct location on all platforms

src/vs/workbench/api/electron-browser/mainThreadEditor.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import EditorCommon = require('vs/editor/common/editorCommon');
+import * as editorCommon from 'vs/editor/common/editorCommon';
 import Event, { Emitter } from 'vs/base/common/event';
 import { IEditor } from 'vs/platform/editor/common/editor';
 import { IModelService } from 'vs/editor/common/services/modelService';
@@ -14,28 +14,162 @@ import { Selection, ISelection } from 'vs/editor/common/core/selection';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
 import { EndOfLine, TextEditorLineNumbersStyle } from 'vs/workbench/api/node/extHostTypes';
 import { TextEditorCursorStyle, cursorStyleToString, RenderLineNumbersType } from 'vs/editor/common/config/editorOptions';
-import { ICursorSelectionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
-import { IResolvedTextEditorConfiguration, ISelectionChangeEvent, ITextEditorConfigurationUpdate, TextEditorRevealType, IApplyEditsOptions, IUndoStopOptions } from 'vs/workbench/api/node/extHost.protocol';
+import { IResolvedTextEditorConfiguration, ITextEditorConfigurationUpdate, TextEditorRevealType, IApplyEditsOptions, IUndoStopOptions, IEditorPropertiesChangeData } from 'vs/workbench/api/node/extHost.protocol';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
-
-function configurationsEqual(a: IResolvedTextEditorConfiguration, b: IResolvedTextEditorConfiguration) {
-	if (a && !b || !a && b) {
-		return false;
-	}
-	if (!a && !b) {
-		return true;
-	}
-	return (
-		a.tabSize === b.tabSize
-		&& a.insertSpaces === b.insertSpaces
-	);
-}
+import { ITextModel, ISingleEditOperation, EndOfLineSequence, IIdentifiedSingleEditOperation, ITextModelUpdateOptions } from 'vs/editor/common/model';
 
 export interface IFocusTracker {
 	onGainedFocus(): void;
 	onLostFocus(): void;
 }
 
+export class MainThreadTextEditorProperties {
+
+	public static readFromEditor(previousProperties: MainThreadTextEditorProperties, model: ITextModel, codeEditor: ICodeEditor): MainThreadTextEditorProperties {
+		const selections = MainThreadTextEditorProperties._readSelectionsFromCodeEditor(previousProperties, codeEditor);
+		const options = MainThreadTextEditorProperties._readOptionsFromCodeEditor(previousProperties, model, codeEditor);
+		const visibleRanges = MainThreadTextEditorProperties._readVisibleRangesFromCodeEditor(previousProperties, codeEditor);
+		return new MainThreadTextEditorProperties(selections, options, visibleRanges);
+	}
+
+	private static _readSelectionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties, codeEditor: ICodeEditor): Selection[] {
+		let result: Selection[] = null;
+		if (codeEditor) {
+			result = codeEditor.getSelections();
+		}
+		if (!result && previousProperties) {
+			result = previousProperties.selections;
+		}
+		if (!result) {
+			result = [new Selection(1, 1, 1, 1)];
+		}
+		return result;
+	}
+
+	private static _readOptionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties, model: ITextModel, codeEditor: ICodeEditor): IResolvedTextEditorConfiguration {
+		if (model.isDisposed()) {
+			// shutdown time
+			return previousProperties.options;
+		}
+
+		let cursorStyle: TextEditorCursorStyle;
+		let lineNumbers: TextEditorLineNumbersStyle;
+		if (codeEditor) {
+			const codeEditorOpts = codeEditor.getConfiguration();
+			cursorStyle = codeEditorOpts.viewInfo.cursorStyle;
+
+			switch (codeEditorOpts.viewInfo.renderLineNumbers) {
+				case RenderLineNumbersType.Off:
+					lineNumbers = TextEditorLineNumbersStyle.Off;
+					break;
+				case RenderLineNumbersType.Relative:
+					lineNumbers = TextEditorLineNumbersStyle.Relative;
+					break;
+				default:
+					lineNumbers = TextEditorLineNumbersStyle.On;
+					break;
+			}
+		} else if (previousProperties) {
+			cursorStyle = previousProperties.options.cursorStyle;
+			lineNumbers = previousProperties.options.lineNumbers;
+		} else {
+			cursorStyle = TextEditorCursorStyle.Line;
+			lineNumbers = TextEditorLineNumbersStyle.On;
+		}
+
+		const modelOptions = model.getOptions();
+		return {
+			insertSpaces: modelOptions.insertSpaces,
+			tabSize: modelOptions.tabSize,
+			cursorStyle: cursorStyle,
+			lineNumbers: lineNumbers
+		};
+	}
+
+	private static _readVisibleRangesFromCodeEditor(previousProperties: MainThreadTextEditorProperties, codeEditor: ICodeEditor): Range[] {
+		if (codeEditor) {
+			return codeEditor.getVisibleRanges();
+		}
+		return [];
+	}
+
+	constructor(
+		public readonly selections: Selection[],
+		public readonly options: IResolvedTextEditorConfiguration,
+		public readonly visibleRanges: Range[]
+	) {
+	}
+
+	public generateDelta(oldProps: MainThreadTextEditorProperties, selectionChangeSource: string): IEditorPropertiesChangeData {
+		let delta: IEditorPropertiesChangeData = {
+			options: null,
+			selections: null,
+			visibleRanges: null
+		};
+
+		if (!oldProps || !MainThreadTextEditorProperties._selectionsEqual(oldProps.selections, this.selections)) {
+			delta.selections = {
+				selections: this.selections,
+				source: selectionChangeSource
+			};
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._optionsEqual(oldProps.options, this.options)) {
+			delta.options = this.options;
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._rangesEqual(oldProps.visibleRanges, this.visibleRanges)) {
+			delta.visibleRanges = this.visibleRanges;
+		}
+
+		if (delta.selections || delta.options || delta.visibleRanges) {
+			// something changed
+			return delta;
+		}
+		// nothing changed
+		return null;
+	}
+
+	private static _selectionsEqual(a: Selection[], b: Selection[]): boolean {
+		if (a.length !== b.length) {
+			return false;
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!a[i].equalsSelection(b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static _rangesEqual(a: Range[], b: Range[]): boolean {
+		if (a.length !== b.length) {
+			return false;
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!a[i].equalsRange(b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static _optionsEqual(a: IResolvedTextEditorConfiguration, b: IResolvedTextEditorConfiguration): boolean {
+		if (a && !b || !a && b) {
+			return false;
+		}
+		if (!a && !b) {
+			return true;
+		}
+		return (
+			a.tabSize === b.tabSize
+			&& a.insertSpaces === b.insertSpaces
+			&& a.cursorStyle === b.cursorStyle
+			&& a.lineNumbers === b.lineNumbers
+		);
+	}
+}
+
 /**
  * Text Editor that is permanently bound to the same model.
  * It can be bound or not to a CodeEditor.
@@ -43,22 +177,19 @@ export interface IFocusTracker {
 export class MainThreadTextEditor {
 
 	private _id: string;
-	private _model: EditorCommon.IModel;
+	private _model: ITextModel;
 	private _modelService: IModelService;
 	private _modelListeners: IDisposable[];
 	private _codeEditor: ICodeEditor;
 	private _focusTracker: IFocusTracker;
 	private _codeEditorListeners: IDisposable[];
 
-	private _lastSelection: Selection[];
-	private _configuration: IResolvedTextEditorConfiguration;
-
-	private _onSelectionChanged: Emitter<ISelectionChangeEvent>;
-	private _onConfigurationChanged: Emitter<IResolvedTextEditorConfiguration>;
+	private _properties: MainThreadTextEditorProperties;
+	private _onPropertiesChanged: Emitter<IEditorPropertiesChangeData>;
 
 	constructor(
 		id: string,
-		model: EditorCommon.IModel,
+		model: ITextModel,
 		codeEditor: ICodeEditor,
 		focusTracker: IFocusTracker,
 		modelService: IModelService
@@ -70,17 +201,16 @@ export class MainThreadTextEditor {
 		this._modelService = modelService;
 		this._codeEditorListeners = [];
 
-		this._onSelectionChanged = new Emitter<ISelectionChangeEvent>();
-		this._onConfigurationChanged = new Emitter<IResolvedTextEditorConfiguration>();
+		this._properties = null;
+		this._onPropertiesChanged = new Emitter<IEditorPropertiesChangeData>();
 
-		this._lastSelection = [new Selection(1, 1, 1, 1)];
 		this._modelListeners = [];
 		this._modelListeners.push(this._model.onDidChangeOptions((e) => {
-			this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
+			this._updatePropertiesNow(null);
 		}));
 
 		this.setCodeEditor(codeEditor);
-		this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
+		this._updatePropertiesNow(null);
 	}
 
 	public dispose(): void {
@@ -90,11 +220,26 @@ export class MainThreadTextEditor {
 		this._codeEditorListeners = dispose(this._codeEditorListeners);
 	}
 
+	private _updatePropertiesNow(selectionChangeSource: string): void {
+		this._setProperties(
+			MainThreadTextEditorProperties.readFromEditor(this._properties, this._model, this._codeEditor),
+			selectionChangeSource
+		);
+	}
+
+	private _setProperties(newProperties: MainThreadTextEditorProperties, selectionChangeSource: string): void {
+		const delta = newProperties.generateDelta(this._properties, selectionChangeSource);
+		this._properties = newProperties;
+		if (delta) {
+			this._onPropertiesChanged.fire(delta);
+		}
+	}
+
 	public getId(): string {
 		return this._id;
 	}
 
-	public getModel(): EditorCommon.IModel {
+	public getModel(): ITextModel {
 		return this._model;
 	}
 
@@ -121,27 +266,30 @@ export class MainThreadTextEditor {
 				this.setCodeEditor(null);
 			}));
 
-			let forwardSelection = (event?: ICursorSelectionChangedEvent) => {
-				this._lastSelection = this._codeEditor.getSelections();
-				this._onSelectionChanged.fire({
-					selections: this._lastSelection,
-					source: event && event.source
-				});
-			};
-			this._codeEditorListeners.push(this._codeEditor.onDidChangeCursorSelection(forwardSelection));
-			if (!Selection.selectionsArrEqual(this._lastSelection, this._codeEditor.getSelections())) {
-				forwardSelection();
-			}
 			this._codeEditorListeners.push(this._codeEditor.onDidFocusEditor(() => {
 				this._focusTracker.onGainedFocus();
 			}));
 			this._codeEditorListeners.push(this._codeEditor.onDidBlurEditor(() => {
 				this._focusTracker.onLostFocus();
 			}));
-			this._codeEditorListeners.push(this._codeEditor.onDidChangeConfiguration(() => {
-				this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
+
+			this._codeEditorListeners.push(this._codeEditor.onDidChangeCursorSelection((e) => {
+				// selection
+				this._updatePropertiesNow(e.source);
 			}));
-			this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
+			this._codeEditorListeners.push(this._codeEditor.onDidChangeConfiguration(() => {
+				// options
+				this._updatePropertiesNow(null);
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidLayoutChange(() => {
+				// visibleRanges
+				this._updatePropertiesNow(null);
+			}));
+			this._codeEditorListeners.push(this._codeEditor.onDidScrollChange(() => {
+				// visibleRanges
+				this._updatePropertiesNow(null);
+			}));
+			this._updatePropertiesNow(null);
 		}
 	}
 
@@ -149,19 +297,12 @@ export class MainThreadTextEditor {
 		return !!this._codeEditor;
 	}
 
-	public get onSelectionChanged(): Event<ISelectionChangeEvent> {
-		return this._onSelectionChanged.event;
+	public getProperties(): MainThreadTextEditorProperties {
+		return this._properties;
 	}
 
-	public get onConfigurationChanged(): Event<IResolvedTextEditorConfiguration> {
-		return this._onConfigurationChanged.event;
-	}
-
-	public getSelections(): Selection[] {
-		if (this._codeEditor) {
-			return this._codeEditor.getSelections();
-		}
-		return this._lastSelection;
+	public get onPropertiesChanged(): Event<IEditorPropertiesChangeData> {
+		return this._onPropertiesChanged.event;
 	}
 
 	public setSelections(selections: ISelection[]): void {
@@ -169,11 +310,12 @@ export class MainThreadTextEditor {
 			this._codeEditor.setSelections(selections);
 			return;
 		}
-		this._lastSelection = selections.map(Selection.liftSelection);
-	}
 
-	public getConfiguration(): IResolvedTextEditorConfiguration {
-		return this._configuration;
+		const newSelections = selections.map(Selection.liftSelection);
+		this._setProperties(
+			new MainThreadTextEditorProperties(newSelections, this._properties.options, this._properties.visibleRanges),
+			null
+		);
 	}
 
 	private _setIndentConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
@@ -196,7 +338,7 @@ export class MainThreadTextEditor {
 			return;
 		}
 
-		let newOpts: EditorCommon.ITextModelUpdateOptions = {};
+		let newOpts: ITextModelUpdateOptions = {};
 		if (typeof newConfiguration.insertSpaces !== 'undefined') {
 			newOpts.insertSpaces = newConfiguration.insertSpaces;
 		}
@@ -238,7 +380,7 @@ export class MainThreadTextEditor {
 		}
 	}
 
-	public setDecorations(key: string, ranges: EditorCommon.IDecorationOptions[]): void {
+	public setDecorations(key: string, ranges: editorCommon.IDecorationOptions[]): void {
 		if (!this._codeEditor) {
 			return;
 		}
@@ -262,16 +404,16 @@ export class MainThreadTextEditor {
 		}
 		switch (revealType) {
 			case TextEditorRevealType.Default:
-				this._codeEditor.revealRange(range, EditorCommon.ScrollType.Smooth);
+				this._codeEditor.revealRange(range, editorCommon.ScrollType.Smooth);
 				break;
 			case TextEditorRevealType.InCenter:
-				this._codeEditor.revealRangeInCenter(range, EditorCommon.ScrollType.Smooth);
+				this._codeEditor.revealRangeInCenter(range, editorCommon.ScrollType.Smooth);
 				break;
 			case TextEditorRevealType.InCenterIfOutsideViewport:
-				this._codeEditor.revealRangeInCenterIfOutsideViewport(range, EditorCommon.ScrollType.Smooth);
+				this._codeEditor.revealRangeInCenterIfOutsideViewport(range, editorCommon.ScrollType.Smooth);
 				break;
 			case TextEditorRevealType.AtTop:
-				this._codeEditor.revealRangeAtTop(range, EditorCommon.ScrollType.Smooth);
+				this._codeEditor.revealRangeAtTop(range, editorCommon.ScrollType.Smooth);
 				break;
 			default:
 				console.warn(`Unknown revealType: ${revealType}`);
@@ -279,47 +421,6 @@ export class MainThreadTextEditor {
 		}
 	}
 
-	private _readConfiguration(model: EditorCommon.IModel, codeEditor: ICodeEditor): IResolvedTextEditorConfiguration {
-		if (model.isDisposed()) {
-			// shutdown time
-			return this._configuration;
-		}
-		let cursorStyle = this._configuration ? this._configuration.cursorStyle : TextEditorCursorStyle.Line;
-		let lineNumbers: TextEditorLineNumbersStyle = this._configuration ? this._configuration.lineNumbers : TextEditorLineNumbersStyle.On;
-		if (codeEditor) {
-			let codeEditorOpts = codeEditor.getConfiguration();
-			cursorStyle = codeEditorOpts.viewInfo.cursorStyle;
-
-			switch (codeEditorOpts.viewInfo.renderLineNumbers) {
-				case RenderLineNumbersType.Off:
-					lineNumbers = TextEditorLineNumbersStyle.Off;
-					break;
-				case RenderLineNumbersType.Relative:
-					lineNumbers = TextEditorLineNumbersStyle.Relative;
-					break;
-				default:
-					lineNumbers = TextEditorLineNumbersStyle.On;
-					break;
-			}
-		}
-
-		let indent = model.getOptions();
-		return {
-			insertSpaces: indent.insertSpaces,
-			tabSize: indent.tabSize,
-			cursorStyle: cursorStyle,
-			lineNumbers: lineNumbers
-		};
-	}
-
-	private _setConfiguration(newConfiguration: IResolvedTextEditorConfiguration): void {
-		if (configurationsEqual(this._configuration, newConfiguration)) {
-			return;
-		}
-		this._configuration = newConfiguration;
-		this._onConfigurationChanged.fire(this._configuration);
-	}
-
 	public isFocused(): boolean {
 		if (this._codeEditor) {
 			return this._codeEditor.isFocused();
@@ -334,7 +435,7 @@ export class MainThreadTextEditor {
 		return editor.getControl() === this._codeEditor;
 	}
 
-	public applyEdits(versionIdCheck: number, edits: EditorCommon.ISingleEditOperation[], opts: IApplyEditsOptions): boolean {
+	public applyEdits(versionIdCheck: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): boolean {
 		if (this._model.getVersionId() !== versionIdCheck) {
 			// throw new Error('Model has changed in the meantime!');
 			// model changed in the meantime
@@ -347,14 +448,13 @@ export class MainThreadTextEditor {
 		}
 
 		if (opts.setEndOfLine === EndOfLine.CRLF) {
-			this._model.setEOL(EditorCommon.EndOfLineSequence.CRLF);
+			this._model.setEOL(EndOfLineSequence.CRLF);
 		} else if (opts.setEndOfLine === EndOfLine.LF) {
-			this._model.setEOL(EditorCommon.EndOfLineSequence.LF);
+			this._model.setEOL(EndOfLineSequence.LF);
 		}
 
-		let transformedEdits = edits.map((edit): EditorCommon.IIdentifiedSingleEditOperation => {
+		let transformedEdits = edits.map((edit): IIdentifiedSingleEditOperation => {
 			return {
-				identifier: null,
 				range: Range.lift(edit.range),
 				text: edit.text,
 				forceMoveMarkers: edit.forceMoveMarkers