From efe6215b271e1e7560902e6fede42654f501afdd Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 07:56:11 +0000 Subject: [PATCH 1/6] Initial plan From 2ae3e21eebb675c8d86cfd0fa3c696c46891cf7a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 08:21:56 +0000 Subject: [PATCH 2/6] Add offWhenInlineCompletions value for editor.quickSuggestions setting Adds a new 'offWhenInlineCompletions' value to the quickSuggestions setting that disables quick suggestions when an inline completion provider is registered for the current model. When no inline completion provider exists, suggestions behave as if set to 'on'. Also adds experiment: { mode: 'auto' } to the quickSuggestions setting. Co-authored-by: jrieken <1794099+jrieken@users.noreply.github.com> --- src/vs/editor/common/config/editorOptions.ts | 13 +++-- .../contrib/suggest/browser/suggestModel.ts | 5 +- .../suggest/test/browser/suggestModel.test.ts | 53 ++++++++++++++++++- src/vs/monaco.d.ts | 2 +- 4 files changed, 65 insertions(+), 8 deletions(-) diff --git a/src/vs/editor/common/config/editorOptions.ts b/src/vs/editor/common/config/editorOptions.ts index a6e7322d41c18..e78b3699d0d46 100644 --- a/src/vs/editor/common/config/editorOptions.ts +++ b/src/vs/editor/common/config/editorOptions.ts @@ -3712,7 +3712,7 @@ class PlaceholderOption extends BaseEditorOptioninput); - const allowedValues: QuickSuggestionsValue[] = ['on', 'inline', 'off']; + const allowedValues: QuickSuggestionsValue[] = ['on', 'inline', 'off', 'offWhenInlineCompletions']; let validatedOther: QuickSuggestionsValue; let validatedComments: QuickSuggestionsValue; let validatedStrings: QuickSuggestionsValue; diff --git a/src/vs/editor/contrib/suggest/browser/suggestModel.ts b/src/vs/editor/contrib/suggest/browser/suggestModel.ts index fcf97af35a620..e6512a1b8c4e8 100644 --- a/src/vs/editor/contrib/suggest/browser/suggestModel.ts +++ b/src/vs/editor/contrib/suggest/browser/suggestModel.ts @@ -415,7 +415,10 @@ export class SuggestModel implements IDisposable { const lineTokens = model.tokenization.getLineTokens(pos.lineNumber); const tokenType = lineTokens.getStandardTokenType(lineTokens.findTokenIndexAtOffset(Math.max(pos.column - 1 - 1, 0))); if (QuickSuggestionsOptions.valueFor(config, tokenType) !== 'on') { - return; + if (QuickSuggestionsOptions.valueFor(config, tokenType) !== 'offWhenInlineCompletions' + || this._languageFeaturesService.inlineCompletionsProvider.has(model)) { + return; + } } } diff --git a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts index dccb55ef44162..e241ebe443d9f 100644 --- a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts +++ b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts @@ -15,7 +15,7 @@ import { Selection } from '../../../../common/core/selection.js'; import { Handler } from '../../../../common/editorCommon.js'; import { ITextModel } from '../../../../common/model.js'; import { TextModel } from '../../../../common/model/textModel.js'; -import { CompletionItemKind, CompletionItemProvider, CompletionList, CompletionTriggerKind, EncodedTokenizationResult, IState, TokenizationRegistry } from '../../../../common/languages.js'; +import { CompletionItemKind, CompletionItemProvider, CompletionList, CompletionTriggerKind, EncodedTokenizationResult, InlineCompletionsProvider, IState, TokenizationRegistry } from '../../../../common/languages.js'; import { MetadataConsts } from '../../../../common/encodedTokenAttributes.js'; import { ILanguageConfigurationService } from '../../../../common/languages/languageConfigurationRegistry.js'; import { NullState } from '../../../../common/languages/nullTokenize.js'; @@ -1228,4 +1228,55 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { }); }); + + test('offWhenInlineCompletions - suppresses quick suggest when inline provider exists', function () { + + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + + // Register a dummy inline completions provider + const inlineProvider: InlineCompletionsProvider = { + provideInlineCompletions: () => ({ items: [] }), + disposeInlineCompletions: () => { } + }; + disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); + + return withOracle((suggestOracle, editor) => { + editor.updateOptions({ quickSuggestions: { comments: 'off', strings: 'off', other: 'offWhenInlineCompletions' } }); + + return new Promise((resolve, reject) => { + const unexpectedSuggestSub = suggestOracle.onDidSuggest(() => { + unexpectedSuggestSub.dispose(); + reject(new Error('Quick suggestions should not have been triggered')); + }); + + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + + // Wait for the quick suggest delay to pass without triggering + setTimeout(() => { + unexpectedSuggestSub.dispose(); + resolve(); + }, 200); + }); + }); + }); + + test('offWhenInlineCompletions - allows quick suggest when no inline provider exists', function () { + + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + + // No inline completions provider registered for 'test' scheme + + return withOracle((suggestOracle, editor) => { + editor.updateOptions({ quickSuggestions: { comments: 'off', strings: 'off', other: 'offWhenInlineCompletions' } }); + + return assertEvent(suggestOracle.onDidSuggest, () => { + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + }, suggestEvent => { + assert.strictEqual(suggestEvent.triggerOptions.auto, true); + assert.strictEqual(suggestEvent.completionModel.items.length, 1); + }); + }); + }); }); diff --git a/src/vs/monaco.d.ts b/src/vs/monaco.d.ts index 22641b4e01a3a..98888e41c6f02 100644 --- a/src/vs/monaco.d.ts +++ b/src/vs/monaco.d.ts @@ -4587,7 +4587,7 @@ declare namespace monaco.editor { cycle?: boolean; } - export type QuickSuggestionsValue = 'on' | 'inline' | 'off'; + export type QuickSuggestionsValue = 'on' | 'inline' | 'off' | 'offWhenInlineCompletions'; /** * Configuration options for quick suggestions From 1177b2af49d70a84e0855460815da0c75639ef82 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 11:43:59 +0000 Subject: [PATCH 3/6] Also check inlineSuggest.enabled for offWhenInlineCompletions When editor.inlineSuggest.enabled is false, offWhenInlineCompletions should allow quick suggestions even if inline completion providers are registered, since they won't produce results anyway. Co-authored-by: jrieken <1794099+jrieken@users.noreply.github.com> --- .../contrib/suggest/browser/suggestModel.ts | 2 +- .../suggest/test/browser/suggestModel.test.ts | 27 +++++++++++++++++++ 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/src/vs/editor/contrib/suggest/browser/suggestModel.ts b/src/vs/editor/contrib/suggest/browser/suggestModel.ts index e6512a1b8c4e8..30c1276d5c4fd 100644 --- a/src/vs/editor/contrib/suggest/browser/suggestModel.ts +++ b/src/vs/editor/contrib/suggest/browser/suggestModel.ts @@ -416,7 +416,7 @@ export class SuggestModel implements IDisposable { const tokenType = lineTokens.getStandardTokenType(lineTokens.findTokenIndexAtOffset(Math.max(pos.column - 1 - 1, 0))); if (QuickSuggestionsOptions.valueFor(config, tokenType) !== 'on') { if (QuickSuggestionsOptions.valueFor(config, tokenType) !== 'offWhenInlineCompletions' - || this._languageFeaturesService.inlineCompletionsProvider.has(model)) { + || (this._languageFeaturesService.inlineCompletionsProvider.has(model) && this._editor.getOption(EditorOption.inlineSuggest).enabled)) { return; } } diff --git a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts index e241ebe443d9f..a9cad96ecae81 100644 --- a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts +++ b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts @@ -1279,4 +1279,31 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { }); }); }); + + test('offWhenInlineCompletions - allows quick suggest when inlineSuggest is disabled', function () { + + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + + // Register a dummy inline completions provider + const inlineProvider: InlineCompletionsProvider = { + provideInlineCompletions: () => ({ items: [] }), + disposeInlineCompletions: () => { } + }; + disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); + + return withOracle((suggestOracle, editor) => { + editor.updateOptions({ + quickSuggestions: { comments: 'off', strings: 'off', other: 'offWhenInlineCompletions' }, + inlineSuggest: { enabled: false } + }); + + return assertEvent(suggestOracle.onDidSuggest, () => { + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + }, suggestEvent => { + assert.strictEqual(suggestEvent.triggerOptions.auto, true); + assert.strictEqual(suggestEvent.completionModel.items.length, 1); + }); + }); + }); }); From 53331dfc51b694f06f06faedc3c8c5e7f7990eb1 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 15:04:16 +0000 Subject: [PATCH 4/6] Support string shorthand for editor.quickSuggestions setting A plain string value like 'off' or 'offWhenInlineCompletions' is now accepted as shorthand for applying the same value to all token types (comments, strings, other). The JSON schema, validate method, and TypeScript types are updated accordingly. Co-authored-by: jrieken <1794099+jrieken@users.noreply.github.com> --- src/vs/editor/common/config/editorOptions.ts | 58 ++++++++++++------- .../suggest/test/browser/suggestModel.test.ts | 56 ++++++++++++++++++ src/vs/monaco.d.ts | 2 +- 3 files changed, 94 insertions(+), 22 deletions(-) diff --git a/src/vs/editor/common/config/editorOptions.ts b/src/vs/editor/common/config/editorOptions.ts index e78b3699d0d46..acc23078daea8 100644 --- a/src/vs/editor/common/config/editorOptions.ts +++ b/src/vs/editor/common/config/editorOptions.ts @@ -496,7 +496,7 @@ export interface IEditorOptions { * Enable quick suggestions (shadow suggestions) * Defaults to true. */ - quickSuggestions?: boolean | IQuickSuggestionsOptions; + quickSuggestions?: boolean | QuickSuggestionsValue | IQuickSuggestionsOptions; /** * Quick suggestions show delay (in ms) * Defaults to 10 (ms) @@ -3729,7 +3729,7 @@ export interface InternalQuickSuggestionsOptions { readonly strings: QuickSuggestionsValue; } -class EditorQuickSuggestions extends BaseEditorOption { +class EditorQuickSuggestions extends BaseEditorOption { public override readonly defaultValue: InternalQuickSuggestionsOptions; @@ -3748,25 +3748,35 @@ class EditorQuickSuggestions extends BaseEditorOption apply same value to all token types + const allowedValues: QuickSuggestionsValue[] = ['on', 'inline', 'off', 'offWhenInlineCompletions']; + const validated = stringSet(input as QuickSuggestionsValue, this.defaultValue.other, allowedValues); + return { comments: validated, strings: validated, other: validated }; + } if (!input || typeof input !== 'object') { - // invalid object + // invalid input return this.defaultValue; } diff --git a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts index a9cad96ecae81..9b41b76c20594 100644 --- a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts +++ b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts @@ -1306,4 +1306,60 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { }); }); }); + + test('string shorthand - "off" disables quick suggestions for all token types', function () { + + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + + return withOracle((suggestOracle, editor) => { + // Use string shorthand instead of object form + editor.updateOptions({ quickSuggestions: 'off' as any }); + + return new Promise((resolve, reject) => { + const sub = suggestOracle.onDidSuggest(() => { + sub.dispose(); + reject(new Error('Quick suggestions should have been suppressed by string shorthand "off"')); + }); + + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + + setTimeout(() => { + sub.dispose(); + resolve(); + }, 200); + }); + }); + }); + + test('string shorthand - "offWhenInlineCompletions" suppresses when inline provider exists', function () { + + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + + const inlineProvider: InlineCompletionsProvider = { + provideInlineCompletions: () => ({ items: [] }), + disposeInlineCompletions: () => { } + }; + disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); + + return withOracle((suggestOracle, editor) => { + // Use string shorthand — applies to all token types + editor.updateOptions({ quickSuggestions: 'offWhenInlineCompletions' as any }); + + return new Promise((resolve, reject) => { + const sub = suggestOracle.onDidSuggest(() => { + sub.dispose(); + reject(new Error('Quick suggestions should have been suppressed by offWhenInlineCompletions shorthand')); + }); + + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + + setTimeout(() => { + sub.dispose(); + resolve(); + }, 200); + }); + }); + }); }); diff --git a/src/vs/monaco.d.ts b/src/vs/monaco.d.ts index 98888e41c6f02..cc990e5b8a26a 100644 --- a/src/vs/monaco.d.ts +++ b/src/vs/monaco.d.ts @@ -3645,7 +3645,7 @@ declare namespace monaco.editor { * Enable quick suggestions (shadow suggestions) * Defaults to true. */ - quickSuggestions?: boolean | IQuickSuggestionsOptions; + quickSuggestions?: boolean | QuickSuggestionsValue | IQuickSuggestionsOptions; /** * Quick suggestions show delay (in ms) * Defaults to 10 (ms) From a062197ba8cd8fa51ce2640d3288dec8c9fd3892 Mon Sep 17 00:00:00 2001 From: Johannes Date: Mon, 9 Feb 2026 16:23:38 +0100 Subject: [PATCH 5/6] Refactor quickSuggestions option to use string shorthand in tests and reorder snippetSuggestions options --- .../editor/contrib/suggest/test/browser/suggestModel.test.ts | 4 ++-- src/vs/monaco.d.ts | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts index 9b41b76c20594..4701782c7d44b 100644 --- a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts +++ b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts @@ -1313,7 +1313,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { return withOracle((suggestOracle, editor) => { // Use string shorthand instead of object form - editor.updateOptions({ quickSuggestions: 'off' as any }); + editor.updateOptions({ quickSuggestions: 'off' }); return new Promise((resolve, reject) => { const sub = suggestOracle.onDidSuggest(() => { @@ -1344,7 +1344,7 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { return withOracle((suggestOracle, editor) => { // Use string shorthand — applies to all token types - editor.updateOptions({ quickSuggestions: 'offWhenInlineCompletions' as any }); + editor.updateOptions({ quickSuggestions: 'offWhenInlineCompletions' }); return new Promise((resolve, reject) => { const sub = suggestOracle.onDidSuggest(() => { diff --git a/src/vs/monaco.d.ts b/src/vs/monaco.d.ts index cc990e5b8a26a..be805ae83dfbc 100644 --- a/src/vs/monaco.d.ts +++ b/src/vs/monaco.d.ts @@ -5374,7 +5374,7 @@ declare namespace monaco.editor { showUnused: IEditorOption; showDeprecated: IEditorOption; inlayHints: IEditorOption>>; - snippetSuggestions: IEditorOption; + snippetSuggestions: IEditorOption; smartSelect: IEditorOption>>; smoothScrolling: IEditorOption; stopRenderingLineAfter: IEditorOption; From 45a475526f97df6e3ab5df1c994263395f558379 Mon Sep 17 00:00:00 2001 From: Johannes Date: Mon, 9 Feb 2026 17:20:56 +0100 Subject: [PATCH 6/6] Add tests for quickSuggestions using string shorthand and faked timers --- .../suggest/test/browser/suggestModel.test.ts | 115 +++++++++--------- 1 file changed, 60 insertions(+), 55 deletions(-) diff --git a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts index 4701782c7d44b..ff465706c0c28 100644 --- a/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts +++ b/src/vs/editor/contrib/suggest/test/browser/suggestModel.test.ts @@ -41,6 +41,7 @@ import { IInstantiationService } from '../../../../../platform/instantiation/com import { getSnippetSuggestSupport, setSnippetSuggestSupport } from '../../browser/suggest.js'; import { IEnvironmentService } from '../../../../../platform/environment/common/environment.js'; import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js'; +import { runWithFakedTimers } from '../../../../../base/test/common/timeTravelScheduler.js'; function createMockEditor(model: TextModel, languageFeaturesService: ILanguageFeaturesService): ITestCodeEditor { @@ -1281,84 +1282,88 @@ suite('SuggestModel - TriggerAndCancelOracle', function () { }); test('offWhenInlineCompletions - allows quick suggest when inlineSuggest is disabled', function () { + return runWithFakedTimers({ useFakeTimers: true }, () => { + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); - disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); - - // Register a dummy inline completions provider - const inlineProvider: InlineCompletionsProvider = { - provideInlineCompletions: () => ({ items: [] }), - disposeInlineCompletions: () => { } - }; - disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); + // Register a dummy inline completions provider + const inlineProvider: InlineCompletionsProvider = { + provideInlineCompletions: () => ({ items: [] }), + disposeInlineCompletions: () => { } + }; + disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); - return withOracle((suggestOracle, editor) => { - editor.updateOptions({ - quickSuggestions: { comments: 'off', strings: 'off', other: 'offWhenInlineCompletions' }, - inlineSuggest: { enabled: false } - }); + return withOracle((suggestOracle, editor) => { + editor.updateOptions({ + quickSuggestions: { comments: 'off', strings: 'off', other: 'offWhenInlineCompletions' }, + inlineSuggest: { enabled: false } + }); - return assertEvent(suggestOracle.onDidSuggest, () => { - editor.setPosition({ lineNumber: 1, column: 4 }); - editor.trigger('keyboard', Handler.Type, { text: 'd' }); - }, suggestEvent => { - assert.strictEqual(suggestEvent.triggerOptions.auto, true); - assert.strictEqual(suggestEvent.completionModel.items.length, 1); + return assertEvent(suggestOracle.onDidSuggest, () => { + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); + }, suggestEvent => { + assert.strictEqual(suggestEvent.triggerOptions.auto, true); + assert.strictEqual(suggestEvent.completionModel.items.length, 1); + }); }); }); }); test('string shorthand - "off" disables quick suggestions for all token types', function () { + return runWithFakedTimers({ useFakeTimers: true }, () => { - disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); - return withOracle((suggestOracle, editor) => { - // Use string shorthand instead of object form - editor.updateOptions({ quickSuggestions: 'off' }); + return withOracle((suggestOracle, editor) => { + // Use string shorthand instead of object form + editor.updateOptions({ quickSuggestions: 'off' }); - return new Promise((resolve, reject) => { - const sub = suggestOracle.onDidSuggest(() => { - sub.dispose(); - reject(new Error('Quick suggestions should have been suppressed by string shorthand "off"')); - }); + return new Promise((resolve, reject) => { + const sub = suggestOracle.onDidSuggest(() => { + sub.dispose(); + reject(new Error('Quick suggestions should have been suppressed by string shorthand "off"')); + }); - editor.setPosition({ lineNumber: 1, column: 4 }); - editor.trigger('keyboard', Handler.Type, { text: 'd' }); + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); - setTimeout(() => { - sub.dispose(); - resolve(); - }, 200); + setTimeout(() => { + sub.dispose(); + resolve(); + }, 200); + }); }); }); }); test('string shorthand - "offWhenInlineCompletions" suppresses when inline provider exists', function () { + return runWithFakedTimers({ useFakeTimers: true }, () => { + disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); - disposables.add(registry.register({ scheme: 'test' }, alwaysSomethingSupport)); - - const inlineProvider: InlineCompletionsProvider = { - provideInlineCompletions: () => ({ items: [] }), - disposeInlineCompletions: () => { } - }; - disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); + const inlineProvider: InlineCompletionsProvider = { + provideInlineCompletions: () => ({ items: [] }), + disposeInlineCompletions: () => { } + }; + disposables.add(languageFeaturesService.inlineCompletionsProvider.register({ scheme: 'test' }, inlineProvider)); - return withOracle((suggestOracle, editor) => { - // Use string shorthand — applies to all token types - editor.updateOptions({ quickSuggestions: 'offWhenInlineCompletions' }); + return withOracle((suggestOracle, editor) => { + // Use string shorthand — applies to all token types + editor.updateOptions({ quickSuggestions: 'offWhenInlineCompletions' }); - return new Promise((resolve, reject) => { - const sub = suggestOracle.onDidSuggest(() => { - sub.dispose(); - reject(new Error('Quick suggestions should have been suppressed by offWhenInlineCompletions shorthand')); - }); + return new Promise((resolve, reject) => { + const sub = suggestOracle.onDidSuggest(() => { + sub.dispose(); + reject(new Error('Quick suggestions should have been suppressed by offWhenInlineCompletions shorthand')); + }); - editor.setPosition({ lineNumber: 1, column: 4 }); - editor.trigger('keyboard', Handler.Type, { text: 'd' }); + editor.setPosition({ lineNumber: 1, column: 4 }); + editor.trigger('keyboard', Handler.Type, { text: 'd' }); - setTimeout(() => { - sub.dispose(); - resolve(); - }, 200); + setTimeout(() => { + sub.dispose(); + resolve(); + }, 200); + }); }); }); });