Merge from vscode 4636be2b71c87bfb0bfe3c94278b447a5efcc1f1 (#8722)

* Merge from vscode 4636be2b71c87bfb0bfe3c94278b447a5efcc1f1

* remove tests that aren't working

src/vs/editor/contrib/codeAction/lightBulbWidget.ts

@@ -225,8 +225,7 @@ registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 	const editorLightBulbForegroundColor = theme.getColor(editorLightBulbForeground);
 	if (editorLightBulbForegroundColor) {
 		collector.addRule(`
-		.monaco-workbench .contentWidgets .codicon-lightbulb,
-		.monaco-workbench .markers-panel-container .codicon-lightbulb {
+		.monaco-editor .contentWidgets .codicon-lightbulb {
 			color: ${editorLightBulbForegroundColor};
 		}`);
 	}
@@ -235,8 +234,7 @@ registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 	const editorLightBulbAutoFixForegroundColor = theme.getColor(editorLightBulbAutoFixForeground);
 	if (editorLightBulbAutoFixForegroundColor) {
 		collector.addRule(`
-		.monaco-workbench .contentWidgets .codicon-lightbulb-autofix,
-		.monaco-workbench .markers-panel-container .codicon-lightbulb-autofix {
+		.monaco-editor .contentWidgets .codicon-lightbulb-autofix {
 			color: ${editorLightBulbAutoFixForegroundColor};
 		}`);
 	}

src/vs/editor/contrib/codelens/codelensWidget.css

@@ -27,6 +27,16 @@
 	cursor: pointer;
 }
 
+.monaco-editor .codelens-decoration .codicon {
+	line-height: inherit;
+	font-size: inherit;
+}
+
+.monaco-editor .codelens-decoration > a:hover .codicon::before {
+	text-decoration: underline;
+	cursor: pointer;
+}
+
 @keyframes fadein {
 	0% { opacity: 0; visibility: visible;}
 	100% { opacity: 1; }

src/vs/editor/contrib/codelens/codelensWidget.ts

@@ -342,9 +342,11 @@ registerThemingParticipant((theme, collector) => {
 	const codeLensForeground = theme.getColor(editorCodeLensForeground);
 	if (codeLensForeground) {
 		collector.addRule(`.monaco-editor .codelens-decoration { color: ${codeLensForeground}; }`);
+		collector.addRule(`.monaco-editor .codelens-decoration .codicon { color: ${codeLensForeground}; }`);
 	}
 	const activeLinkForeground = theme.getColor(editorActiveLinkForeground);
 	if (activeLinkForeground) {
 		collector.addRule(`.monaco-editor .codelens-decoration > a:hover { color: ${activeLinkForeground} !important; }`);
+		collector.addRule(`.monaco-editor .codelens-decoration > a:hover .codicon { color: ${activeLinkForeground} !important; }`);
 	}
 });

src/vs/editor/contrib/documentSymbols/media/symbol-icons.css

@@ -3,22 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-.monaco-workbench .monaco-icon-label.deprecated {
+.monaco-icon-label.deprecated {
 	text-decoration: line-through;
 	opacity: 0.66;
 }
-
-.monaco-workbench .symbol-icon.inline {
-	display: flex;
-	align-items: center;
-	padding-left: 0;
-}
-
-.monaco-workbench .symbol-icon.block {
-	display: inline-block;
-	height: 14px;
-	width: 16px;
-	min-height: 14px;
-	min-width: 16px;
-	background-position: center;
-}

src/vs/editor/contrib/documentSymbols/outlineTree.ts

@@ -22,7 +22,7 @@ import { MarkerSeverity } from 'vs/platform/markers/common/markers';
 import { IThemeService, registerThemingParticipant, ITheme, ICssStyleCollector } from 'vs/platform/theme/common/themeService';
 import { registerColor, listErrorForeground, listWarningForeground, foreground } from 'vs/platform/theme/common/colorRegistry';
 import { IdleValue } from 'vs/base/common/async';
-import { IResourceConfigurationService } from 'vs/editor/common/services/resourceConfiguration';
+import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfigurationService';
 import { URI } from 'vs/base/common/uri';
 
 export type OutlineItem = OutlineGroup | OutlineElement;
@@ -282,7 +282,7 @@ export class OutlineFilter implements ITreeFilter<OutlineItem> {
 
 	constructor(
 		private readonly _prefix: string,
-		@IResourceConfigurationService private readonly _textResourceConfigService: IResourceConfigurationService,
+		@ITextResourceConfigurationService private readonly _textResourceConfigService: ITextResourceConfigurationService,
 	) { }
 
 	filter(element: OutlineItem): boolean {
@@ -540,300 +540,168 @@ registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 
 	const symbolIconArrayColor = theme.getColor(SYMBOL_ICON_ARRAY_FOREGROUND);
 	if (symbolIconArrayColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-array {
-				color: ${symbolIconArrayColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-array { color: ${symbolIconArrayColor} !important; }`);
 	}
 
 	const symbolIconBooleanColor = theme.getColor(SYMBOL_ICON_BOOLEAN_FOREGROUND);
 	if (symbolIconBooleanColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-boolean {
-				color: ${symbolIconBooleanColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-boolean { color: ${symbolIconBooleanColor} !important; }`);
 	}
 
 	const symbolIconClassColor = theme.getColor(SYMBOL_ICON_CLASS_FOREGROUND);
 	if (symbolIconClassColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-class {
-				color: ${symbolIconClassColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-class { color: ${symbolIconClassColor} !important; }`);
 	}
 
 	const symbolIconMethodColor = theme.getColor(SYMBOL_ICON_METHOD_FOREGROUND);
 	if (symbolIconMethodColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-method {
-				color: ${symbolIconMethodColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-method { color: ${symbolIconMethodColor} !important; }`);
 	}
 
 	const symbolIconColorColor = theme.getColor(SYMBOL_ICON_COLOR_FOREGROUND);
 	if (symbolIconColorColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-color {
-				color: ${symbolIconColorColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-color { color: ${symbolIconColorColor} !important; }`);
 	}
 
 	const symbolIconConstantColor = theme.getColor(SYMBOL_ICON_CONSTANT_FOREGROUND);
 	if (symbolIconConstantColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-constant {
-				color: ${symbolIconConstantColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-constant { color: ${symbolIconConstantColor} !important; }`);
 	}
 
 	const symbolIconConstructorColor = theme.getColor(SYMBOL_ICON_CONSTRUCTOR_FOREGROUND);
 	if (symbolIconConstructorColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-constructor {
-				color: ${symbolIconConstructorColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-constructor { color: ${symbolIconConstructorColor} !important; }`);
 	}
 
 	const symbolIconEnumeratorColor = theme.getColor(SYMBOL_ICON_ENUMERATOR_FOREGROUND);
 	if (symbolIconEnumeratorColor) {
 		collector.addRule(`
-			.monaco-workbench .codicon-symbol-value,
-			.monaco-workbench .codicon-symbol-enum {
-				color: ${symbolIconEnumeratorColor} !important;
-			}
-		`);
+			.codicon-symbol-value,.codicon-symbol-enum { color: ${symbolIconEnumeratorColor} !important; }`);
 	}
 
 	const symbolIconEnumeratorMemberColor = theme.getColor(SYMBOL_ICON_ENUMERATOR_MEMBER_FOREGROUND);
 	if (symbolIconEnumeratorMemberColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-enum-member {
-				color: ${symbolIconEnumeratorMemberColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-enum-member { color: ${symbolIconEnumeratorMemberColor} !important; }`);
 	}
 
 	const symbolIconEventColor = theme.getColor(SYMBOL_ICON_EVENT_FOREGROUND);
 	if (symbolIconEventColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-event {
-				color: ${symbolIconEventColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-event { color: ${symbolIconEventColor} !important; }`);
 	}
 
 	const symbolIconFieldColor = theme.getColor(SYMBOL_ICON_FIELD_FOREGROUND);
 	if (symbolIconFieldColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-field {
-				color: ${symbolIconFieldColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-field { color: ${symbolIconFieldColor} !important; }`);
 	}
 
 	const symbolIconFileColor = theme.getColor(SYMBOL_ICON_FILE_FOREGROUND);
 	if (symbolIconFileColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-file {
-				color: ${symbolIconFileColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-file { color: ${symbolIconFileColor} !important; }`);
 	}
 
 	const symbolIconFolderColor = theme.getColor(SYMBOL_ICON_FOLDER_FOREGROUND);
 	if (symbolIconFolderColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-folder {
-				color: ${symbolIconFolderColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-folder { color: ${symbolIconFolderColor} !important; }`);
 	}
 
 	const symbolIconFunctionColor = theme.getColor(SYMBOL_ICON_FUNCTION_FOREGROUND);
 	if (symbolIconFunctionColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-function {
-				color: ${symbolIconFunctionColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-function { color: ${symbolIconFunctionColor} !important; }`);
 	}
 
 	const symbolIconInterfaceColor = theme.getColor(SYMBOL_ICON_INTERFACE_FOREGROUND);
 	if (symbolIconInterfaceColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-interface {
-				color: ${symbolIconInterfaceColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-interface { color: ${symbolIconInterfaceColor} !important; }`);
 	}
 
 	const symbolIconKeyColor = theme.getColor(SYMBOL_ICON_KEY_FOREGROUND);
 	if (symbolIconKeyColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-key {
-				color: ${symbolIconKeyColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-key { color: ${symbolIconKeyColor} !important; }`);
 	}
 
 	const symbolIconKeywordColor = theme.getColor(SYMBOL_ICON_KEYWORD_FOREGROUND);
 	if (symbolIconKeywordColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-keyword {
-				color: ${symbolIconKeywordColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-keyword { color: ${symbolIconKeywordColor} !important; }`);
 	}
 
 	const symbolIconModuleColor = theme.getColor(SYMBOL_ICON_MODULE_FOREGROUND);
 	if (symbolIconModuleColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-module {
-				color: ${symbolIconModuleColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-module { color: ${symbolIconModuleColor} !important; }`);
 	}
 
 	const outlineNamespaceColor = theme.getColor(SYMBOL_ICON_NAMESPACE_FOREGROUND);
 	if (outlineNamespaceColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-namespace {
-				color: ${outlineNamespaceColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-namespace { color: ${outlineNamespaceColor} !important; }`);
 	}
 
 	const symbolIconNullColor = theme.getColor(SYMBOL_ICON_NULL_FOREGROUND);
 	if (symbolIconNullColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-null {
-				color: ${symbolIconNullColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-null { color: ${symbolIconNullColor} !important; }`);
 	}
 
 	const symbolIconNumberColor = theme.getColor(SYMBOL_ICON_NUMBER_FOREGROUND);
 	if (symbolIconNumberColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-number {
-				color: ${symbolIconNumberColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-number { color: ${symbolIconNumberColor} !important; }`);
 	}
 
 	const symbolIconObjectColor = theme.getColor(SYMBOL_ICON_OBJECT_FOREGROUND);
 	if (symbolIconObjectColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-object {
-				color: ${symbolIconObjectColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-object { color: ${symbolIconObjectColor} !important; }`);
 	}
 
 	const symbolIconOperatorColor = theme.getColor(SYMBOL_ICON_OPERATOR_FOREGROUND);
 	if (symbolIconOperatorColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-operator {
-				color: ${symbolIconOperatorColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-operator { color: ${symbolIconOperatorColor} !important; }`);
 	}
 
 	const symbolIconPackageColor = theme.getColor(SYMBOL_ICON_PACKAGE_FOREGROUND);
 	if (symbolIconPackageColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-package {
-				color: ${symbolIconPackageColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-package { color: ${symbolIconPackageColor} !important; }`);
 	}
 
 	const symbolIconPropertyColor = theme.getColor(SYMBOL_ICON_PROPERTY_FOREGROUND);
 	if (symbolIconPropertyColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-property {
-				color: ${symbolIconPropertyColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-property { color: ${symbolIconPropertyColor} !important; }`);
 	}
 
 	const symbolIconReferenceColor = theme.getColor(SYMBOL_ICON_REFERENCE_FOREGROUND);
 	if (symbolIconReferenceColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-reference {
-				color: ${symbolIconReferenceColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-reference { color: ${symbolIconReferenceColor} !important; }`);
 	}
 
 	const symbolIconSnippetColor = theme.getColor(SYMBOL_ICON_SNIPPET_FOREGROUND);
 	if (symbolIconSnippetColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-snippet {
-				color: ${symbolIconSnippetColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-snippet { color: ${symbolIconSnippetColor} !important; }`);
 	}
 
 	const symbolIconStringColor = theme.getColor(SYMBOL_ICON_STRING_FOREGROUND);
 	if (symbolIconStringColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-string {
-				color: ${symbolIconStringColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-string { color: ${symbolIconStringColor} !important; }`);
 	}
 
 	const symbolIconStructColor = theme.getColor(SYMBOL_ICON_STRUCT_FOREGROUND);
 	if (symbolIconStructColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-struct {
-				color: ${symbolIconStructColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-struct { color: ${symbolIconStructColor} !important; }`);
 	}
 
 	const symbolIconTextColor = theme.getColor(SYMBOL_ICON_TEXT_FOREGROUND);
 	if (symbolIconTextColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-text {
-				color: ${symbolIconTextColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-text { color: ${symbolIconTextColor} !important; }`);
 	}
 
 	const symbolIconTypeParameterColor = theme.getColor(SYMBOL_ICON_TYPEPARAMETER_FOREGROUND);
 	if (symbolIconTypeParameterColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-type-parameter {
-				color: ${symbolIconTypeParameterColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-type-parameter { color: ${symbolIconTypeParameterColor} !important; }`);
 	}
 
 	const symbolIconUnitColor = theme.getColor(SYMBOL_ICON_UNIT_FOREGROUND);
 	if (symbolIconUnitColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-unit {
-				color: ${symbolIconUnitColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-unit { color: ${symbolIconUnitColor} !important; }`);
 	}
 
 	const symbolIconVariableColor = theme.getColor(SYMBOL_ICON_VARIABLE_FOREGROUND);
 	if (symbolIconVariableColor) {
-		collector.addRule(`
-			.monaco-workbench .codicon-symbol-variable {
-				color: ${symbolIconVariableColor} !important;
-			}
-		`);
+		collector.addRule(`.codicon-symbol-variable { color: ${symbolIconVariableColor} !important; }`);
 	}
 
 });

src/vs/editor/contrib/find/findWidget.css

@@ -3,31 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/* Checkbox */
-
-.monaco-checkbox .codicon-selection {
-	width: 12px;
-	height: 12px;
-	border: 1px solid black;
-	background-color: transparent;
-	display: inline-block;
-}
-
-.monaco-checkbox .checkbox {
-	position: absolute;
-	overflow: hidden;
-	clip: rect(0 0 0 0);
-	height: 1px;
-	width: 1px;
-	margin: -1px;
-	padding: 0;
-	border: 0;
-}
-
-.monaco-checkbox .checkbox:checked + .codicon-selection {
-	background-color: black;
-}
-
 /* Find widget */
 .monaco-editor .find-widget {
 	position: absolute;
@@ -184,40 +159,6 @@
 	cursor: default;
 }
 
-.monaco-editor .find-widget .monaco-checkbox {
-	width: 20px;
-	height: 20px;
-	display: inline-block;
-	vertical-align: middle;
-	margin-left: 3px;
-}
-
-.monaco-editor .find-widget .monaco-checkbox .codicon-selection {
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	width: 20px;
-	height: 20px;
-	border: none;
-}
-
-.monaco-editor .find-widget .monaco-checkbox .checkbox:disabled + .codicon-selection {
-	opacity: 0.3;
-	cursor: default;
-}
-
-.monaco-editor .find-widget .monaco-checkbox .checkbox:not(:disabled) + .codicon-selection {
-	cursor: pointer;
-}
-
-.monaco-editor .find-widget .monaco-checkbox .checkbox:not(:disabled):hover:before + .codicon-selection {
-	background-color: #DDD;
-}
-
-.monaco-editor .find-widget .monaco-checkbox .checkbox:checked + .codicon-selection {
-	background-color: rgba(100, 100, 100, 0.2);
-}
-
 .monaco-editor .find-widget > .replace-part {
 	display: none;
 }
@@ -238,8 +179,7 @@
 }
 
 /* REDUCED */
-.monaco-editor .find-widget.reduced-find-widget .matchesCount,
-.monaco-editor .find-widget.reduced-find-widget .monaco-checkbox {
+.monaco-editor .find-widget.reduced-find-widget .matchesCount {
 	display:none;
 }
 
@@ -271,13 +211,8 @@
 	margin-left: -4px;
 }
 
-.monaco-editor.vs-dark .find-widget .monaco-checkbox .checkbox:not(:disabled):hover:before + .codicon-selection {
-	background-color: rgba(255, 255, 255, 0.1);
-}
-
 .monaco-editor.hc-black .find-widget .button:not(.disabled):hover,
-.monaco-editor.vs-dark .find-widget .button:not(.disabled):hover,
-.monaco-editor.vs-dark .find-widget .monaco-checkbox:not(.disabled):hover {
+.monaco-editor.vs-dark .find-widget .button:not(.disabled):hover {
 	background-color: rgba(255, 255, 255, 0.1);
 }
 
@@ -286,7 +221,3 @@
 	top: 1px;
 	left: 2px;
 }
-
-.monaco-editor.hc-black .find-widget .monaco-checkbox .checkbox:checked + .codicon-selection {
-	background-color: rgba(255, 255, 255, 0.1);
-}

src/vs/editor/contrib/find/findWidget.ts

@@ -1341,20 +1341,10 @@ registerThemingParticipant((theme, collector) => {
 		}
 	}
 
-	const inputActiveBorder = theme.getColor(inputActiveOptionBorder);
-	if (inputActiveBorder) {
-		collector.addRule(`.monaco-editor .find-widget .monaco-checkbox .checkbox:checked + .label { border: 1px solid ${inputActiveBorder.toString()}; }`);
-	}
-
-	const inputActiveBackground = theme.getColor(inputActiveOptionBackground);
-	if (inputActiveBackground) {
-		collector.addRule(`.monaco-editor .find-widget .monaco-checkbox .checkbox:checked + .label { background-color: ${inputActiveBackground.toString()}; }`);
-	}
-
 	// This rule is used to override the outline color for synthetic-focus find input.
 	const focusOutline = theme.getColor(focusBorder);
 	if (focusOutline) {
-		collector.addRule(`.monaco-workbench .monaco-editor .find-widget .monaco-inputbox.synthetic-focus { outline-color: ${focusOutline}; }`);
+		collector.addRule(`.monaco-editor .find-widget .monaco-inputbox.synthetic-focus { outline-color: ${focusOutline}; }`);
 
 	}
 });

src/vs/editor/contrib/multicursor/test/multicursor.test.ts

@@ -69,7 +69,8 @@ suite('Multicursor selection', () => {
 		store: (key: string, value: any) => { queryState[key] = value; return Promise.resolve(); },
 		remove: (key) => undefined,
 		logStorage: () => undefined,
-		migrate: (toWorkspace) => Promise.resolve(undefined)
+		migrate: (toWorkspace) => Promise.resolve(undefined),
+		flush: () => undefined
 	} as IStorageService);
 
 	test('issue #8817: Cursor position changes when you cancel multicursor', () => {

src/vs/editor/contrib/suggest/suggestController.ts

@@ -259,20 +259,21 @@ export class SuggestController implements IEditorContribution {
 			this.editor.pushUndoStop();
 		}
 
-		if (Array.isArray(suggestion.additionalTextEdits)) {
-			this.editor.executeEdits('suggestController.additionalTextEdits', suggestion.additionalTextEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)));
-		}
+		// compute overwrite[Before|After] deltas BEFORE applying extra edits
+		const info = this.getOverwriteInfo(item, Boolean(flags & InsertFlags.AlternativeOverwriteConfig));
 
 		// keep item in memory
 		this._memoryService.memorize(model, this.editor.getPosition(), item);
 
+		if (Array.isArray(suggestion.additionalTextEdits)) {
+			this.editor.executeEdits('suggestController.additionalTextEdits', suggestion.additionalTextEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)));
+		}
+
 		let { insertText } = suggestion;
 		if (!(suggestion.insertTextRules! & CompletionItemInsertTextRule.InsertAsSnippet)) {
 			insertText = SnippetParser.escape(insertText);
 		}
 
-		const info = this.getOverwriteInfo(item, Boolean(flags & InsertFlags.AlternativeOverwriteConfig));
-
 		SnippetController2.get(this.editor).insert(insertText, {
 			overwriteBefore: info.overwriteBefore,
 			overwriteAfter: info.overwriteAfter,

src/vs/editor/contrib/suggest/suggestWidget.ts

@@ -4,6 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import 'vs/css!./media/suggest';
+import 'vs/base/browser/ui/codiconLabel/codiconLabel'; // The codicon symbol styles are defined here and must be loaded
+import 'vs/editor/contrib/documentSymbols/outlineTree'; // The codicon symbol colors are defined here and must be loaded
 import * as nls from 'vs/nls';
 import { createMatches } from 'vs/base/common/filters';
 import * as strings from 'vs/base/common/strings';

src/vs/editor/contrib/suggest/test/suggestController.test.ts

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { SuggestController } from 'vs/editor/contrib/suggest/suggestController';
+import { createTestCodeEditor, TestCodeEditor } from 'vs/editor/test/browser/testCodeEditor';
+import { TextModel } from 'vs/editor/common/model/textModel';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+import { IStorageService, InMemoryStorageService } from 'vs/platform/storage/common/storage';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { MockKeybindingService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
+import { ISuggestMemoryService } from 'vs/editor/contrib/suggest/suggestMemory';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { URI } from 'vs/base/common/uri';
+import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
+import { mock } from 'vs/editor/contrib/suggest/test/suggestModel.test';
+import { Selection } from 'vs/editor/common/core/selection';
+import { CompletionProviderRegistry, CompletionItemKind, CompletionItemInsertTextRule } from 'vs/editor/common/modes';
+import { Event } from 'vs/base/common/event';
+import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
+
+suite('SuggestController', function () {
+
+	const disposables = new DisposableStore();
+
+	let controller: SuggestController;
+	let editor: TestCodeEditor;
+	let model: TextModel;
+
+	setup(function () {
+		disposables.clear();
+
+		const serviceCollection = new ServiceCollection(
+			[ITelemetryService, NullTelemetryService],
+			[IStorageService, new InMemoryStorageService()],
+			[IKeybindingService, new MockKeybindingService()],
+			[IEditorWorkerService, new class extends mock<IEditorWorkerService>() {
+				computeWordRanges() {
+					return Promise.resolve({});
+				}
+			}],
+			[ISuggestMemoryService, new class extends mock<ISuggestMemoryService>() {
+				memorize(): void { }
+				select(): number { return 0; }
+			}]
+		);
+
+		model = TextModel.createFromString('', undefined, undefined, URI.from({ scheme: 'test-ctrl', path: '/path.tst' }));
+		editor = createTestCodeEditor({
+			model,
+			serviceCollection,
+		});
+
+		editor.registerAndInstantiateContribution(SnippetController2.ID, SnippetController2);
+		controller = editor.registerAndInstantiateContribution(SuggestController.ID, SuggestController);
+	});
+
+	test('postfix completion reports incorrect position #86984', async function () {
+		disposables.add(CompletionProviderRegistry.register({ scheme: 'test-ctrl' }, {
+			provideCompletionItems(doc, pos) {
+				return {
+					suggestions: [{
+						kind: CompletionItemKind.Snippet,
+						label: 'let',
+						insertText: 'let ${1:name} = foo$0',
+						insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+						range: { startLineNumber: 1, startColumn: 9, endLineNumber: 1, endColumn: 11 },
+						additionalTextEdits: [{
+							text: '',
+							range: { startLineNumber: 1, startColumn: 5, endLineNumber: 1, endColumn: 9 }
+						}]
+					}]
+				};
+			}
+		}));
+
+		editor.setValue('    foo.le');
+		editor.setSelection(new Selection(1, 11, 1, 11));
+
+		// trigger
+		let p1 = Event.toPromise(controller.model.onDidSuggest);
+		controller.triggerSuggest();
+		await p1;
+
+		//
+		let p2 = Event.toPromise(controller.model.onDidCancel);
+		controller.acceptSelectedSuggestion(false, false);
+		await p2;
+
+		assert.equal(editor.getValue(), '    let name = foo');
+	});
+});