Merge VS Code 1.23.1 (#1520)

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

@@ -21,7 +21,7 @@ suite('SuggestMemories', function () {
 
 	setup(function () {
 		pos = { lineNumber: 1, column: 1 };
-		buffer = TextModel.createFromString('This is some text');
+		buffer = TextModel.createFromString('This is some text.\nthis.\nfoo: ,');
 		items = [
 			createSuggestItem('foo', 0),
 			createSuggestItem('bar', 0)
@@ -39,7 +39,9 @@ suite('SuggestMemories', function () {
 		mem.memorize(buffer, pos, null);
 	});
 
-	test('ShyMemories', function () {
+	test('LRUMemory', function () {
+
+		pos = { lineNumber: 2, column: 6 };
 
 		const mem = new LRUMemory();
 		mem.memorize(buffer, pos, items[1]);
@@ -59,7 +61,19 @@ suite('SuggestMemories', function () {
 			createSuggestItem('new1', 0),
 			createSuggestItem('new2', 0)
 		]), 0);
+	});
 
+	test('intellisense is not showing top options first #43429', function () {
+		// ensure we don't memorize for whitespace prefixes
+
+		pos = { lineNumber: 2, column: 6 };
+		const mem = new LRUMemory();
+
+		mem.memorize(buffer, pos, items[1]);
+		assert.equal(mem.select(buffer, pos, items), 1);
+
+		assert.equal(mem.select(buffer, { lineNumber: 3, column: 5 }, items), 0); // foo: |,
+		assert.equal(mem.select(buffer, { lineNumber: 3, column: 6 }, items), 1); // foo: ,|
 	});
 
 	test('PrefixMemory', function () {

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

@@ -5,12 +5,12 @@
 'use strict';
 
 import * as assert from 'assert';
-import Event from 'vs/base/common/event';
+import { Event } from 'vs/base/common/event';
 import URI from 'vs/base/common/uri';
-import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { IDisposable, dispose, Disposable } from 'vs/base/common/lifecycle';
 import { TextModel } from 'vs/editor/common/model/textModel';
 import { Handler } from 'vs/editor/common/editorCommon';
-import { ISuggestSupport, ISuggestResult, SuggestRegistry, SuggestTriggerKind } from 'vs/editor/common/modes';
+import { ISuggestSupport, ISuggestResult, SuggestRegistry, SuggestTriggerKind, LanguageIdentifier, TokenizationRegistry, IState, MetadataConsts } from 'vs/editor/common/modes';
 import { SuggestModel, LineContext } from 'vs/editor/contrib/suggest/suggestModel';
 import { TestCodeEditor, MockScopeLocation } from 'vs/editor/test/browser/testCodeEditor';
 import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
@@ -21,54 +21,121 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
 import { EditOperation } from 'vs/editor/common/core/editOperation';
 import { Range } from 'vs/editor/common/core/range';
+import { Selection } from 'vs/editor/common/core/selection';
 import { CoreEditingCommands } from 'vs/editor/browser/controller/coreCommands';
 import { SuggestController } from 'vs/editor/contrib/suggest/suggestController';
 import { IStorageService, NullStorageService } from 'vs/platform/storage/common/storage';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
 import { ISelectedSuggestion } from 'vs/editor/contrib/suggest/suggestWidget';
+import { MockMode } from 'vs/editor/test/common/mocks/mockMode';
+import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
+import { TokenizationResult2 } from 'vs/editor/common/core/token';
+import { NULL_STATE } from 'vs/editor/common/modes/nullMode';
+import { TestNotificationService } from 'vs/platform/notification/test/common/testNotificationService';
+import { INotificationService } from 'vs/platform/notification/common/notification';
 
 function createMockEditor(model: TextModel): TestCodeEditor {
 	const contextKeyService = new MockContextKeyService();
 	const telemetryService = NullTelemetryService;
+	const notificationService = new TestNotificationService();
 	const instantiationService = new InstantiationService(new ServiceCollection(
 		[IContextKeyService, contextKeyService],
 		[ITelemetryService, telemetryService],
-		[IStorageService, NullStorageService]
+		[IStorageService, NullStorageService],
+		[INotificationService, TestNotificationService]
 	));
 
-	const editor = new TestCodeEditor(new MockScopeLocation(), {}, instantiationService, contextKeyService);
+	const editor = new TestCodeEditor(new MockScopeLocation(), {}, false, instantiationService, contextKeyService, notificationService);
 	editor.setModel(model);
 	return editor;
 }
 
 suite('SuggestModel - Context', function () {
+	const OUTER_LANGUAGE_ID = new LanguageIdentifier('outerMode', 3);
+	const INNER_LANGUAGE_ID = new LanguageIdentifier('innerMode', 4);
 
-	let model: TextModel;
+	class OuterMode extends MockMode {
+		constructor() {
+			super(OUTER_LANGUAGE_ID);
+			this._register(LanguageConfigurationRegistry.register(this.getLanguageIdentifier(), {}));
 
-	setup(function () {
-		model = TextModel.createFromString('Das Pferd frisst keinen Gurkensalat - Philipp Reis 1861.\nWer hat\'s erfunden?');
+			this._register(TokenizationRegistry.register(this.getLanguageIdentifier().language, {
+				getInitialState: (): IState => NULL_STATE,
+				tokenize: undefined,
+				tokenize2: (line: string, state: IState): TokenizationResult2 => {
+					const tokensArr: number[] = [];
+					let prevLanguageId: LanguageIdentifier = undefined;
+					for (let i = 0; i < line.length; i++) {
+						const languageId = (line.charAt(i) === 'x' ? INNER_LANGUAGE_ID : OUTER_LANGUAGE_ID);
+						if (prevLanguageId !== languageId) {
+							tokensArr.push(i);
+							tokensArr.push((languageId.id << MetadataConsts.LANGUAGEID_OFFSET));
+						}
+						prevLanguageId = languageId;
+					}
+
+					const tokens = new Uint32Array(tokensArr.length);
+					for (let i = 0; i < tokens.length; i++) {
+						tokens[i] = tokensArr[i];
+					}
+					return new TokenizationResult2(tokens, state);
+				}
+			}));
+		}
+	}
+
+	class InnerMode extends MockMode {
+		constructor() {
+			super(INNER_LANGUAGE_ID);
+			this._register(LanguageConfigurationRegistry.register(this.getLanguageIdentifier(), {}));
+		}
+	}
+
+	const assertAutoTrigger = (model: TextModel, offset: number, expected: boolean, message?: string): void => {
+		const pos = model.getPositionAt(offset);
+		const editor = createMockEditor(model);
+		editor.setPosition(pos);
+		assert.equal(LineContext.shouldAutoTrigger(editor), expected, message);
+		editor.dispose();
+	};
+
+	let disposables: Disposable[] = [];
+
+	setup(() => {
+		disposables = [];
 	});
 
 	teardown(function () {
-		model.dispose();
+		dispose(disposables);
+		disposables = [];
 	});
 
 	test('Context - shouldAutoTrigger', function () {
+		const model = TextModel.createFromString('Das Pferd frisst keinen Gurkensalat - Philipp Reis 1861.\nWer hat\'s erfunden?');
+		disposables.push(model);
 
-		function assertAutoTrigger(offset: number, expected: boolean): void {
-			const pos = model.getPositionAt(offset);
-			const editor = createMockEditor(model);
-			editor.setPosition(pos);
-			assert.equal(LineContext.shouldAutoTrigger(editor), expected);
-			editor.dispose();
-		}
-
-		assertAutoTrigger(3, true); // end of word, Das|
-		assertAutoTrigger(4, false); // no word Das |
-		assertAutoTrigger(1, false); // middle of word D|as
-		assertAutoTrigger(55, false); // number, 1861|
+		assertAutoTrigger(model, 3, true, 'end of word, Das|');
+		assertAutoTrigger(model, 4, false, 'no word Das |');
+		assertAutoTrigger(model, 1, false, 'middle of word D|as');
+		assertAutoTrigger(model, 55, false, 'number, 1861|');
 	});
 
+	test('shouldAutoTrigger at embedded language boundaries', () => {
+		const outerMode = new OuterMode();
+		const innerMode = new InnerMode();
+		disposables.push(outerMode, innerMode);
+
+		const model = TextModel.createFromString('a<xx>a<x>', undefined, outerMode.getLanguageIdentifier());
+		disposables.push(model);
+
+		assertAutoTrigger(model, 1, true, 'a|<x — should trigger at end of word');
+		assertAutoTrigger(model, 2, false, 'a<|x — should NOT trigger at start of word');
+		assertAutoTrigger(model, 3, false, 'a<x|x —  should NOT trigger in middle of word');
+		assertAutoTrigger(model, 4, true, 'a<xx|> — should trigger at boundary between languages');
+		assertAutoTrigger(model, 5, false, 'a<xx>|a — should NOT trigger at start of word');
+		assertAutoTrigger(model, 6, true, 'a<xx>a|< — should trigger at end of word');
+		assertAutoTrigger(model, 8, true, 'a<xx>a<x|> — should trigger at end of word at boundary');
+	});
 });
 
 suite('SuggestModel - TriggerAndCancelOracle', function () {
@@ -616,4 +683,24 @@ suite('SuggestModel - TriggerAndCancelOracle', function () {
 			);
 		});
 	});
+
+	test('Completion unexpectedly triggers on second keypress of an edit group in a snippet #43523', function () {
+
+		disposables.push(SuggestRegistry.register({ scheme: 'test' }, alwaysSomethingSupport));
+
+		return withOracle((model, editor) => {
+			return assertEvent(model.onDidSuggest, () => {
+				editor.setValue('d');
+				editor.setSelection(new Selection(1, 1, 1, 2));
+				editor.trigger('keyboard', Handler.Type, { text: 'e' });
+
+			}, event => {
+				assert.equal(event.auto, true);
+				assert.equal(event.completionModel.items.length, 1);
+				const [first] = event.completionModel.items;
+
+				assert.equal(first.support, alwaysSomethingSupport);
+			});
+		});
+	});
 });