Merge VS Code 1.31.1 (#4283)

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

@@ -4,39 +4,31 @@
  *--------------------------------------------------------------------------------------------*/
 import * as assert from 'assert';
 import { IPosition } from 'vs/editor/common/core/position';
-import { CompletionList, CompletionItemProvider, CompletionItem, CompletionItemKind } from 'vs/editor/common/modes';
+import * as modes from 'vs/editor/common/modes';
 import { CompletionModel } from 'vs/editor/contrib/suggest/completionModel';
-import { ISuggestionItem, getSuggestionComparator, ensureLowerCaseVariants } from 'vs/editor/contrib/suggest/suggest';
+import { CompletionItem, getSuggestionComparator } from 'vs/editor/contrib/suggest/suggest';
 import { WordDistance } from 'vs/editor/contrib/suggest/wordDistance';
 
-export function createSuggestItem(label: string, overwriteBefore: number, kind = CompletionItemKind.Property, incomplete: boolean = false, position: IPosition = { lineNumber: 1, column: 1 }): ISuggestionItem {
-
-	return new class implements ISuggestionItem {
-
-		position = position;
-
-		suggestion: CompletionItem = {
-			label,
-			range: { startLineNumber: position.lineNumber, startColumn: position.column - overwriteBefore, endLineNumber: position.lineNumber, endColumn: position.column },
-			insertText: label,
-			kind
-		};
-
-		container: CompletionList = {
-			incomplete,
-			suggestions: [this.suggestion]
-		};
-
-		support: CompletionItemProvider = {
-			provideCompletionItems(): any {
-				return;
-			}
-		};
-
-		resolve(): Promise<void> {
-			return null;
+export function createSuggestItem(label: string, overwriteBefore: number, kind = modes.CompletionItemKind.Property, incomplete: boolean = false, position: IPosition = { lineNumber: 1, column: 1 }, sortText?: string, filterText?: string): CompletionItem {
+	const suggestion: modes.CompletionItem = {
+		label,
+		sortText,
+		filterText,
+		range: { startLineNumber: position.lineNumber, startColumn: position.column - overwriteBefore, endLineNumber: position.lineNumber, endColumn: position.column },
+		insertText: label,
+		kind
+	};
+	const container: modes.CompletionList = {
+		incomplete,
+		suggestions: [suggestion]
+	};
+	const provider: modes.CompletionItemProvider = {
+		provideCompletionItems(): any {
+			return;
 		}
 	};
+
+	return new CompletionItem(position, suggestion, container, provider, undefined!);
 }
 suite('CompletionModel', function () {
 
@@ -100,7 +92,7 @@ suite('CompletionModel', function () {
 		const complete = model.adopt(incomplete);
 
 		assert.equal(incomplete.size, 1);
-		assert.ok(incomplete.has(incompleteItem.support));
+		assert.ok(incomplete.has(incompleteItem.provider));
 		assert.equal(complete.length, 1);
 		assert.ok(complete[0] === completeItem);
 	});
@@ -130,7 +122,7 @@ suite('CompletionModel', function () {
 		const complete = model.adopt(incomplete);
 
 		assert.equal(incomplete.size, 1);
-		assert.ok(incomplete.has(incompleteItem1.support));
+		assert.ok(incomplete.has(incompleteItem1.provider));
 		assert.equal(complete.length, 5);
 	});
 
@@ -150,18 +142,18 @@ suite('CompletionModel', function () {
 		assert.equal(model.items.length, 4);
 
 		const [a, b, c, d] = model.items;
-		assert.equal(a.suggestion.label, '    </div');
-		assert.equal(b.suggestion.label, '    </tag');
-		assert.equal(c.suggestion.label, 'a');
-		assert.equal(d.suggestion.label, 'p');
+		assert.equal(a.completion.label, '    </div');
+		assert.equal(b.completion.label, '    </tag');
+		assert.equal(c.completion.label, 'a');
+		assert.equal(d.completion.label, 'p');
 	});
 
 	test('keep snippet sorting with prefix: top, #25495', function () {
 
 		model = new CompletionModel([
-			createSuggestItem('Snippet1', 1, CompletionItemKind.Snippet),
-			createSuggestItem('tnippet2', 1, CompletionItemKind.Snippet),
-			createSuggestItem('semver', 1, CompletionItemKind.Property),
+			createSuggestItem('Snippet1', 1, modes.CompletionItemKind.Snippet),
+			createSuggestItem('tnippet2', 1, modes.CompletionItemKind.Snippet),
+			createSuggestItem('semver', 1, modes.CompletionItemKind.Property),
 		], 1, {
 				leadingLineContent: 's',
 				characterCountDelta: 0
@@ -169,8 +161,8 @@ suite('CompletionModel', function () {
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;
-		assert.equal(a.suggestion.label, 'Snippet1');
-		assert.equal(b.suggestion.label, 'semver');
+		assert.equal(a.completion.label, 'Snippet1');
+		assert.equal(b.completion.label, 'semver');
 		assert.ok(a.score < b.score); // snippet really promoted
 
 	});
@@ -178,9 +170,9 @@ suite('CompletionModel', function () {
 	test('keep snippet sorting with prefix: bottom, #25495', function () {
 
 		model = new CompletionModel([
-			createSuggestItem('snippet1', 1, CompletionItemKind.Snippet),
-			createSuggestItem('tnippet2', 1, CompletionItemKind.Snippet),
-			createSuggestItem('Semver', 1, CompletionItemKind.Property),
+			createSuggestItem('snippet1', 1, modes.CompletionItemKind.Snippet),
+			createSuggestItem('tnippet2', 1, modes.CompletionItemKind.Snippet),
+			createSuggestItem('Semver', 1, modes.CompletionItemKind.Property),
 		], 1, {
 				leadingLineContent: 's',
 				characterCountDelta: 0
@@ -188,16 +180,16 @@ suite('CompletionModel', function () {
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;
-		assert.equal(a.suggestion.label, 'Semver');
-		assert.equal(b.suggestion.label, 'snippet1');
+		assert.equal(a.completion.label, 'Semver');
+		assert.equal(b.completion.label, 'snippet1');
 		assert.ok(a.score < b.score); // snippet really demoted
 	});
 
 	test('keep snippet sorting with prefix: inline, #25495', function () {
 
 		model = new CompletionModel([
-			createSuggestItem('snippet1', 1, CompletionItemKind.Snippet),
-			createSuggestItem('tnippet2', 1, CompletionItemKind.Snippet),
+			createSuggestItem('snippet1', 1, modes.CompletionItemKind.Snippet),
+			createSuggestItem('tnippet2', 1, modes.CompletionItemKind.Snippet),
 			createSuggestItem('Semver', 1),
 		], 1, {
 				leadingLineContent: 's',
@@ -206,15 +198,14 @@ suite('CompletionModel', function () {
 
 		assert.equal(model.items.length, 2);
 		const [a, b] = model.items;
-		assert.equal(a.suggestion.label, 'snippet1');
-		assert.equal(b.suggestion.label, 'Semver');
+		assert.equal(a.completion.label, 'snippet1');
+		assert.equal(b.completion.label, 'Semver');
 		assert.ok(a.score > b.score); // snippet really demoted
 	});
 
 	test('filterText seems ignored in autocompletion, #26874', function () {
 
-		const item1 = createSuggestItem('Map - java.util', 1);
-		item1.suggestion.filterText = 'Map';
+		const item1 = createSuggestItem('Map - java.util', 1, undefined, undefined, undefined, undefined, 'Map');
 		const item2 = createSuggestItem('Map - java.util', 1);
 
 		model = new CompletionModel([item1, item2], 1, {
@@ -233,17 +224,8 @@ suite('CompletionModel', function () {
 
 	test('Vscode 1.12 no longer obeys \'sortText\' in completion items (from language server), #26096', function () {
 
-		const item1 = createSuggestItem('<- groups', 2, CompletionItemKind.Property, false, { lineNumber: 1, column: 3 });
-		item1.suggestion.filterText = '  groups';
-		item1.suggestion.sortText = '00002';
-
-		const item2 = createSuggestItem('source', 0, CompletionItemKind.Property, false, { lineNumber: 1, column: 3 });
-		item2.suggestion.filterText = 'source';
-		item2.suggestion.sortText = '00001';
-
-		ensureLowerCaseVariants(item1.suggestion);
-		ensureLowerCaseVariants(item2.suggestion);
-
+		const item1 = createSuggestItem('<- groups', 2, modes.CompletionItemKind.Property, false, { lineNumber: 1, column: 3 }, '00002', '  groups');
+		const item2 = createSuggestItem('source', 0, modes.CompletionItemKind.Property, false, { lineNumber: 1, column: 3 }, '00001', 'source');
 		const items = [item1, item2].sort(getSuggestionComparator('inline'));
 
 		model = new CompletionModel(items, 3, {
@@ -254,8 +236,8 @@ suite('CompletionModel', function () {
 		assert.equal(model.items.length, 2);
 
 		const [first, second] = model.items;
-		assert.equal(first.suggestion.label, 'source');
-		assert.equal(second.suggestion.label, '<- groups');
+		assert.equal(first.completion.label, 'source');
+		assert.equal(second.completion.label, '<- groups');
 	});
 
 	test('Score only filtered items when typing more, score all when typing less', function () {
@@ -302,9 +284,9 @@ suite('CompletionModel', function () {
 		assert.equal(model.items.length, 3);
 
 		const [first, second, third] = model.items;
-		assert.equal(first.suggestion.label, 'result'); // best with `rult`
-		assert.equal(second.suggestion.label, 'replyToUser');  // best with `rltu`
-		assert.equal(third.suggestion.label, 'randomLolut');  // best with `rlut`
+		assert.equal(first.completion.label, 'result'); // best with `rult`
+		assert.equal(second.completion.label, 'replyToUser');  // best with `rltu`
+		assert.equal(third.completion.label, 'randomLolut');  // best with `rlut`
 	});
 
 	test('Emmet suggestion not appearing at the top of the list in jsx files, #39518', function () {
@@ -322,8 +304,8 @@ suite('CompletionModel', function () {
 		model.lineContext = { leadingLineContent: 'form', characterCountDelta: 4 };
 		assert.equal(model.items.length, 5);
 		const [first, second, third] = model.items;
-		assert.equal(first.suggestion.label, 'form'); // best with `form`
-		assert.equal(second.suggestion.label, 'form:get');  // best with `form`
-		assert.equal(third.suggestion.label, 'from');  // best with `from`
+		assert.equal(first.completion.label, 'form'); // best with `form`
+		assert.equal(second.completion.label, 'form:get');  // best with `form`
+		assert.equal(third.completion.label, 'from');  // best with `from`
 	});
 });

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

@@ -9,6 +9,7 @@ import { CompletionProviderRegistry, CompletionItemKind } from 'vs/editor/common
 import { provideSuggestionItems } from 'vs/editor/contrib/suggest/suggest';
 import { Position } from 'vs/editor/common/core/position';
 import { TextModel } from 'vs/editor/common/model/textModel';
+import { Range } from 'vs/editor/common/core/range';
 
 
 suite('Suggest', function () {
@@ -20,21 +21,24 @@ suite('Suggest', function () {
 
 		model = TextModel.createFromString('FOO\nbar\BAR\nfoo', undefined, undefined, URI.parse('foo:bar/path'));
 		registration = CompletionProviderRegistry.register({ pattern: 'bar/path', scheme: 'foo' }, {
-			provideCompletionItems() {
+			provideCompletionItems(_doc, pos) {
 				return {
 					incomplete: false,
 					suggestions: [{
 						label: 'aaa',
 						kind: CompletionItemKind.Snippet,
-						insertText: 'aaa'
+						insertText: 'aaa',
+						range: Range.fromPositions(pos)
 					}, {
 						label: 'zzz',
 						kind: CompletionItemKind.Snippet,
-						insertText: 'zzz'
+						insertText: 'zzz',
+						range: Range.fromPositions(pos)
 					}, {
 						label: 'fff',
 						kind: CompletionItemKind.Property,
-						insertText: 'fff'
+						insertText: 'fff',
+						range: Range.fromPositions(pos)
 					}]
 				};
 			}
@@ -49,31 +53,31 @@ suite('Suggest', function () {
 	test('sort - snippet inline', async function () {
 		const items = await provideSuggestionItems(model, new Position(1, 1), 'inline');
 		assert.equal(items.length, 3);
-		assert.equal(items[0].suggestion.label, 'aaa');
-		assert.equal(items[1].suggestion.label, 'fff');
-		assert.equal(items[2].suggestion.label, 'zzz');
+		assert.equal(items[0].completion.label, 'aaa');
+		assert.equal(items[1].completion.label, 'fff');
+		assert.equal(items[2].completion.label, 'zzz');
 	});
 
 	test('sort - snippet top', async function () {
 		const items = await provideSuggestionItems(model, new Position(1, 1), 'top');
 		assert.equal(items.length, 3);
-		assert.equal(items[0].suggestion.label, 'aaa');
-		assert.equal(items[1].suggestion.label, 'zzz');
-		assert.equal(items[2].suggestion.label, 'fff');
+		assert.equal(items[0].completion.label, 'aaa');
+		assert.equal(items[1].completion.label, 'zzz');
+		assert.equal(items[2].completion.label, 'fff');
 	});
 
 	test('sort - snippet bottom', async function () {
 		const items = await provideSuggestionItems(model, new Position(1, 1), 'bottom');
 		assert.equal(items.length, 3);
-		assert.equal(items[0].suggestion.label, 'fff');
-		assert.equal(items[1].suggestion.label, 'aaa');
-		assert.equal(items[2].suggestion.label, 'zzz');
+		assert.equal(items[0].completion.label, 'fff');
+		assert.equal(items[1].completion.label, 'aaa');
+		assert.equal(items[2].completion.label, 'zzz');
 	});
 
 	test('sort - snippet none', async function () {
 		const items = await provideSuggestionItems(model, new Position(1, 1), 'none');
 		assert.equal(items.length, 1);
-		assert.equal(items[0].suggestion.label, 'fff');
+		assert.equal(items[0].completion.label, 'fff');
 	});
 
 	test('only from', function () {
@@ -98,7 +102,7 @@ suite('Suggest', function () {
 			registration.dispose();
 
 			assert.equal(items.length, 1);
-			assert.ok(items[0].support === foo);
+			assert.ok(items[0].provider === foo);
 		});
 	});
 });

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

@@ -7,15 +7,15 @@ import * as assert from 'assert';
 import { LRUMemory, NoMemory, PrefixMemory, Memory } from 'vs/editor/contrib/suggest/suggestMemory';
 import { ITextModel } from 'vs/editor/common/model';
 import { TextModel } from 'vs/editor/common/model/textModel';
-import { ICompletionItem } from 'vs/editor/contrib/suggest/completionModel';
 import { createSuggestItem } from 'vs/editor/contrib/suggest/test/completionModel.test';
 import { IPosition } from 'vs/editor/common/core/position';
+import { CompletionItem } from 'vs/editor/contrib/suggest/suggest';
 
 suite('SuggestMemories', function () {
 
 	let pos: IPosition;
 	let buffer: ITextModel;
-	let items: ICompletionItem[];
+	let items: CompletionItem[];
 
 	setup(function () {
 		pos = { lineNumber: 1, column: 1 };
@@ -29,7 +29,7 @@ suite('SuggestMemories', function () {
 	test('AbstractMemory, select', function () {
 
 		const mem = new class extends Memory {
-			memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void {
+			memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void {
 				throw new Error('Method not implemented.');
 			} toJSON(): object {
 				throw new Error('Method not implemented.');
@@ -43,9 +43,9 @@ suite('SuggestMemories', function () {
 		let item2 = createSuggestItem('bazz', 0);
 		let item3 = createSuggestItem('bazz', 0);
 		let item4 = createSuggestItem('bazz', 0);
-		item1.suggestion.preselect = false;
-		item2.suggestion.preselect = true;
-		item3.suggestion.preselect = true;
+		item1.completion.preselect = false;
+		item2.completion.preselect = true;
+		item3.completion.preselect = true;
 
 		assert.equal(mem.select(buffer, pos, [item1, item2, item3, item4]), 1);
 	});
@@ -55,9 +55,9 @@ suite('SuggestMemories', function () {
 		let item2 = createSuggestItem('bazz', 0);
 		let item3 = createSuggestItem('bazz', 0);
 		let item4 = createSuggestItem('bazz', 0);
-		item1.suggestion.preselect = false;
-		item2.suggestion.preselect = true;
-		item3.suggestion.preselect = true;
+		item1.completion.preselect = false;
+		item2.completion.preselect = true;
+		item3.completion.preselect = true;
 		let items = [item1, item2, item3, item4];
 
 
@@ -74,7 +74,7 @@ suite('SuggestMemories', function () {
 		assert.equal(mem.select(buffer, pos, []), 0);
 
 		mem.memorize(buffer, pos, items[0]);
-		mem.memorize(buffer, pos, null);
+		mem.memorize(buffer, pos, null!);
 	});
 
 	test('LRUMemory', () => {

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

@@ -9,6 +9,7 @@ import { URI } from 'vs/base/common/uri';
 import { CoreEditingCommands } from 'vs/editor/browser/controller/coreCommands';
 import { EditOperation } from 'vs/editor/common/core/editOperation';
 import { Range } from 'vs/editor/common/core/range';
+import { Position } from 'vs/editor/common/core/position';
 import { Selection } from 'vs/editor/common/core/selection';
 import { TokenizationResult2 } from 'vs/editor/common/core/token';
 import { Handler } from 'vs/editor/common/editorCommon';
@@ -27,6 +28,8 @@ import { IStorageService, InMemoryStorageService } from 'vs/platform/storage/com
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
 import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
+import { ISuggestMemoryService } from 'vs/editor/contrib/suggest/suggestMemory';
+import { ITextModel } from 'vs/editor/common/model';
 
 export interface Ctor<T> {
 	new(): T;
@@ -42,7 +45,15 @@ function createMockEditor(model: TextModel): TestCodeEditor {
 		model: model,
 		serviceCollection: new ServiceCollection(
 			[ITelemetryService, NullTelemetryService],
-			[IStorageService, new InMemoryStorageService()]
+			[IStorageService, new InMemoryStorageService()],
+			[ISuggestMemoryService, new class implements ISuggestMemoryService {
+				_serviceBrand: any;
+				memorize(): void {
+				}
+				select(): number {
+					return -1;
+				}
+			}],
 		),
 	});
 	editor.registerAndInstantiateContribution(SnippetController2);
@@ -60,7 +71,7 @@ suite('SuggestModel - Context', function () {
 
 			this._register(TokenizationRegistry.register(this.getLanguageIdentifier().language, {
 				getInitialState: (): IState => NULL_STATE,
-				tokenize: undefined,
+				tokenize: undefined!,
 				tokenize2: (line: string, state: IState): TokenizationResult2 => {
 					const tokensArr: number[] = [];
 					let prevLanguageId: LanguageIdentifier | undefined = undefined;
@@ -140,6 +151,11 @@ suite('SuggestModel - Context', function () {
 suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 
+	function getDefaultSuggestRange(model: ITextModel, position: Position) {
+		const wordUntil = model.getWordUntilPosition(position);
+		return new Range(position.lineNumber, wordUntil.startColumn, position.lineNumber, wordUntil.endColumn);
+	}
+
 	const alwaysEmptySupport: CompletionItemProvider = {
 		provideCompletionItems(doc, pos): CompletionList {
 			return {
@@ -156,7 +172,8 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				suggestions: [{
 					label: doc.getWordUntilPosition(pos).word,
 					kind: CompletionItemKind.Property,
-					insertText: 'foofoo'
+					insertText: 'foofoo',
+					range: getDefaultSuggestRange(doc, pos)
 				}]
 			};
 		}
@@ -213,39 +230,27 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 		return withOracle(model => {
 
 			return Promise.all([
-				assertEvent(model.onDidCancel, function () {
-					model.cancel();
-				}, function (event) {
-					assert.equal(event.retrigger, false);
-				}),
 
-				assertEvent(model.onDidCancel, function () {
-					model.cancel(true);
+				assertEvent(model.onDidTrigger, function () {
+					model.trigger({ auto: true, shy: false });
 				}, function (event) {
-					assert.equal(event.retrigger, true);
-				}),
+					assert.equal(event.auto, true);
 
-				// cancel on trigger
-				assertEvent(model.onDidCancel, function () {
-					model.trigger({ auto: false });
-				}, function (event) {
-					assert.equal(event.retrigger, false);
-				}),
-
-				assertEvent(model.onDidCancel, function () {
-					model.trigger({ auto: false }, true);
-				}, function (event) {
-					assert.equal(event.retrigger, true);
+					return assertEvent(model.onDidCancel, function () {
+						model.cancel();
+					}, function (event) {
+						assert.equal(event.retrigger, false);
+					});
 				}),
 
 				assertEvent(model.onDidTrigger, function () {
-					model.trigger({ auto: true });
+					model.trigger({ auto: true, shy: false });
 				}, function (event) {
 					assert.equal(event.auto, true);
 				}),
 
 				assertEvent(model.onDidTrigger, function () {
-					model.trigger({ auto: false });
+					model.trigger({ auto: false, shy: false });
 				}, function (event) {
 					assert.equal(event.auto, false);
 				})
@@ -261,12 +266,12 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 		return withOracle(model => {
 			return Promise.all([
 				assertEvent(model.onDidCancel, function () {
-					model.trigger({ auto: true });
+					model.trigger({ auto: true, shy: false });
 				}, function (event) {
 					assert.equal(event.retrigger, false);
 				}),
 				assertEvent(model.onDidSuggest, function () {
-					model.trigger({ auto: false });
+					model.trigger({ auto: false, shy: false });
 				}, function (event) {
 					assert.equal(event.auto, false);
 					assert.equal(event.isFrozen, false);
@@ -290,7 +295,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
 
-				assert.equal(first.support, alwaysSomethingSupport);
+				assert.equal(first.provider, alwaysSomethingSupport);
 			});
 		});
 	});
@@ -304,7 +309,8 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 					suggestions: [{
 						label: 'My Table',
 						kind: CompletionItemKind.Property,
-						insertText: 'My Table'
+						insertText: 'My Table',
+						range: getDefaultSuggestRange(doc, pos)
 					}]
 				};
 			}
@@ -316,7 +322,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 			return assertEvent(model.onDidSuggest, () => {
 				// make sure completionModel starts here!
-				model.trigger({ auto: true });
+				model.trigger({ auto: true, shy: false });
 			}, event => {
 
 				return assertEvent(model.onDidSuggest, () => {
@@ -327,7 +333,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 					assert.equal(event.auto, true);
 					assert.equal(event.completionModel.items.length, 1);
 					const [first] = event.completionModel.items;
-					assert.equal(first.suggestion.label, 'My Table');
+					assert.equal(first.completion.label, 'My Table');
 
 					return assertEvent(model.onDidSuggest, () => {
 						editor.setPosition({ lineNumber: 1, column: 3 });
@@ -337,7 +343,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 						assert.equal(event.auto, true);
 						assert.equal(event.completionModel.items.length, 1);
 						const [first] = event.completionModel.items;
-						assert.equal(first.suggestion.label, 'My Table');
+						assert.equal(first.completion.label, 'My Table');
 					});
 				});
 			});
@@ -390,7 +396,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				assert.equal(event.auto, true);
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
-				assert.equal(first.suggestion.label, 'foo.bar');
+				assert.equal(first.completion.label, 'foo.bar');
 
 				return assertEvent(model.onDidSuggest, () => {
 					editor.trigger('keyboard', Handler.Type, { text: '.' });
@@ -399,8 +405,8 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 					assert.equal(event.auto, true);
 					assert.equal(event.completionModel.items.length, 2);
 					const [first, second] = event.completionModel.items;
-					assert.equal(first.suggestion.label, 'foo.bar');
-					assert.equal(second.suggestion.label, 'boom');
+					assert.equal(first.completion.label, 'foo.bar');
+					assert.equal(second.completion.label, 'boom');
 				});
 			});
 		});
@@ -412,11 +418,11 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 		return withOracle((model, editor) => {
 
-			editor.getModel().setValue('fo');
+			editor.getModel()!.setValue('fo');
 			editor.setPosition({ lineNumber: 1, column: 3 });
 
 			return assertEvent(model.onDidSuggest, () => {
-				model.trigger({ auto: false });
+				model.trigger({ auto: false, shy: false });
 			}, event => {
 				assert.equal(event.auto, false);
 				assert.equal(event.isFrozen, false);
@@ -437,11 +443,11 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 		return withOracle((model, editor) => {
 
-			editor.getModel().setValue('fo');
+			editor.getModel()!.setValue('fo');
 			editor.setPosition({ lineNumber: 1, column: 3 });
 
 			return assertEvent(model.onDidSuggest, () => {
-				model.trigger({ auto: false });
+				model.trigger({ auto: false, shy: false });
 			}, event => {
 				assert.equal(event.auto, false);
 				assert.equal(event.isFrozen, false);
@@ -474,11 +480,11 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 		return withOracle((model, editor) => {
 
-			editor.getModel().setValue('foo');
+			editor.getModel()!.setValue('foo');
 			editor.setPosition({ lineNumber: 1, column: 4 });
 
 			return assertEvent(model.onDidSuggest, () => {
-				model.trigger({ auto: false });
+				model.trigger({ auto: false, shy: false });
 			}, event => {
 				assert.equal(event.auto, false);
 				assert.equal(event.completionModel.incomplete.size, 1);
@@ -511,11 +517,11 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 		return withOracle((model, editor) => {
 
-			editor.getModel().setValue('foo');
+			editor.getModel()!.setValue('foo');
 			editor.setPosition({ lineNumber: 1, column: 4 });
 
 			return assertEvent(model.onDidSuggest, () => {
-				model.trigger({ auto: false });
+				model.trigger({ auto: false, shy: false });
 			}, event => {
 				assert.equal(event.auto, false);
 				assert.equal(event.completionModel.incomplete.size, 1);
@@ -542,7 +548,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 			triggerCharacters: ['.'],
 			provideCompletionItems(doc, pos, context): CompletionList {
 				assert.equal(context.triggerKind, CompletionTriggerKind.TriggerCharacter);
-				triggerCharacter = context.triggerCharacter;
+				triggerCharacter = context.triggerCharacter!;
 				return {
 					incomplete: false,
 					suggestions: [
@@ -598,7 +604,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				editor.trigger('keyboard', Handler.Type, { text: 'a' });
 			}, event => {
 				assert.equal(event.completionModel.items.length, 1);
-				assert.equal(event.completionModel.items[0].suggestion.label, 'abc');
+				assert.equal(event.completionModel.items[0].completion.label, 'abc');
 
 				return assertEvent(model.onDidSuggest, () => {
 					editor.executeEdits('test', [EditOperation.replace(new Range(1, 1, 1, 2), 'ä')]);
@@ -606,7 +612,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				}, event => {
 					// suggest model changed to äbc
 					assert.equal(event.completionModel.items.length, 1);
-					assert.equal(event.completionModel.items[0].suggestion.label, 'äbc');
+					assert.equal(event.completionModel.items[0].completion.label, 'äbc');
 
 				});
 			});
@@ -626,7 +632,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
 
-				assert.equal(first.support, alwaysSomethingSupport);
+				assert.equal(first.provider, alwaysSomethingSupport);
 			});
 
 			await assertEvent(model.onDidSuggest, () => {
@@ -637,7 +643,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
 
-				assert.equal(first.support, alwaysSomethingSupport);
+				assert.equal(first.provider, alwaysSomethingSupport);
 			});
 		});
 	});
@@ -674,12 +680,12 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 
 			await assertEvent(sugget.onDidSuggest, () => {
 				editor.setPosition({ lineNumber: 1, column: 3 });
-				sugget.trigger({ auto: false });
+				sugget.trigger({ auto: false, shy: false });
 			}, event => {
 
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
-				assert.equal(first.suggestion.label, 'bar');
+				assert.equal(first.completion.label, 'bar');
 
 				ctrl._onDidSelectItem({ item: first, index: 0, model: event.completionModel });
 			});
@@ -706,7 +712,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 				assert.equal(event.completionModel.items.length, 1);
 				const [first] = event.completionModel.items;
 
-				assert.equal(first.support, alwaysSomethingSupport);
+				assert.equal(first.provider, alwaysSomethingSupport);
 			});
 		});
 	});
@@ -721,7 +727,13 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 			provideCompletionItems(doc, pos) {
 				return {
 					incomplete: true,
-					suggestions: [{ kind: CompletionItemKind.Folder, label: 'CompleteNot', insertText: 'Incomplete', sortText: 'a', overwriteBefore: pos.column - 1 }],
+					suggestions: [{
+						kind: CompletionItemKind.Folder,
+						label: 'CompleteNot',
+						insertText: 'Incomplete',
+						sortText: 'a',
+						range: getDefaultSuggestRange(doc, pos)
+					}],
 					dispose() { disposeA += 1; }
 				};
 			}
@@ -730,7 +742,13 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 			provideCompletionItems(doc, pos) {
 				return {
 					incomplete: false,
-					suggestions: [{ kind: CompletionItemKind.Folder, label: 'Complete', insertText: 'Complete', sortText: 'z', overwriteBefore: pos.column - 1 }],
+					suggestions: [{
+						kind: CompletionItemKind.Folder,
+						label: 'Complete',
+						insertText: 'Complete',
+						sortText: 'z',
+						range: getDefaultSuggestRange(doc, pos)
+					}],
 					dispose() { disposeB += 1; }
 				};
 			},