jiebi/CodeConvo huggingface dataset:
private readonly recommendationsByPattern = new Map<string, IStringDictionary<IFileOpenCondition[]>>(); private readonly fileBasedRecommendations = new Map<string, { recommendedTime: number }>(); private readonly fileBasedImportantRecommendations = new Set<string>(); <del> private readonly processedFileExtensions: string[] = []; </del> get recommendations(): ReadonlyArray<ExtensionRecommendation> { const recommendations: ExtensionRecommendation[] = [];
constructor( @IExtensionsWorkbenchService private readonly extensionsWorkbenchService: IExtensionsWorkbenchService, <del> @IPaneCompositePartService private readonly paneCompositeService: IPaneCompositePartService, </del> @IModelService private readonly modelService: IModelService, @ILanguageService private readonly languageService: ILanguageService, @IProductService productService: IProductService, <del> @INotificationService private readonly notificationService: INotificationService, @ITelemetryService private readonly telemetryService: ITelemetryService, </del> @IStorageService private readonly storageService: IStorageService, @IExtensionRecommendationNotificationService private readonly extensionRecommendationNotificationService: IExtensionRecommendationNotificationService, @IExtensionIgnoredRecommendationsService private readonly extensionIgnoredRecommendationsService: IExtensionIgnoredRecommendationsService, @IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService, <del> @IExtensionManagementServerService private readonly extensionManagementServerService: IExtensionManagementServerService, </del> ) { super(); this.fileOpenRecommendations = {};
} // re-schedule this bit of the operation to be off the critical path - in case glob-match is slow <del> this._register(disposableTimeout(() => this.promptRecommendations(uri, model), 0)); } private promptRecommendations(uri: URI, model: ITextModel): void { if (this.promptImportantRecommendations(uri, model)) { return; } const fileExtension = extname(uri).toLowerCase(); if (!this.processedFileExtensions.includes(fileExtension)) { this.processedFileExtensions.push(fileExtension); this.promptRecommendedExtensionForFileExtension(uri, fileExtension); } </del> <ins> this._register(disposableTimeout(() => this.promptImportantRecommendations(uri, model), 0)); </ins> } /** * Prompt the user to either install the recommended extension for the file type in the current editor model * or prompt to search the marketplace if it has extensions that can support the file type */ <del> private promptImportantRecommendations(uri: URI, model: ITextModel, extensionRecommendations?: IStringDictionary<IFileOpenCondition[]>): boolean { </del> <ins> private promptImportantRecommendations(uri: URI, model: ITextModel, extensionRecommendations?: IStringDictionary<IFileOpenCondition[]>): void { </ins> const pattern = extname(uri).toLowerCase(); extensionRecommendations = extensionRecommendations ?? this.recommendationsByPattern.get(pattern) ?? this.fileOpenRecommendations; const extensionRecommendationEntries = Object.entries(extensionRecommendations); if (extensionRecommendationEntries.length === 0) { <del> return false; </del> <ins> return; </ins> } const processedPathGlobs = new Map<string, boolean>();
return this._view; } <del> const toolbar = this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, { </del> <ins> const toolbar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, { </ins> actionViewItemProvider: action => { return createActionViewItem(this.instantiationService, action); }, renderDropdownAsChildElement: true <del> }); </del> <ins> })); </ins> const deleteToolbar = this._register(this.instantiationService.invokeFunction(accessor => createDeleteToolbar(accessor, this.toolbarContainer, 'cell-delete-toolbar'))); if (model.deleteActions.primary.length !== 0 || model.deleteActions.secondary.length !== 0) {
debug!(self.logger, "Starting server with command... {:?}", cmd); <ins> // On Windows spawning a code-server binary will run cmd.exe /c C:pathtocode-server.cmd... // This spawns a cmd.exe window for the user, which if they close will kill the code-server process // and disconnect the tunnel. To prevent this, pass the CREATE_NO_WINDOW flag to the Command // only on Windows. // Original issue: https://github.com/microsoft/vscode/issues/184058 // Partial fix: https://github.com/microsoft/vscode/pull/184621 #[cfg(target_os = "windows")] let cmd = cmd.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW); </ins> let child = cmd .stderr(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped())
this._sequencer.queue(key, async () => { await this.resolvedStorageService; <del> if (this.type !== 'persisted') { </del> <ins> if (this.type !== 'persisted' && !this._environmentService.disableKeytar) { </ins> this._logService.trace('[NativeSecretStorageService] Notifying user that secrets are not being stored on disk.'); await this.notifyOfNoEncryptionOnce(); }
private _revealInViewWithMinimalScrolling(viewIndex: number, firstLine?: boolean) { const firstIndex = this.view.firstVisibleIndex; <del> if (viewIndex <= firstIndex) { </del> <ins> const elementHeight = this.view.elementHeight(viewIndex); if (viewIndex <= firstIndex || elementHeight >= this.view.renderHeight) { </ins> this._revealInternal(viewIndex, true, CellRevealPosition.Top, firstLine); } else { this._revealInternal(viewIndex, true, CellRevealPosition.Bottom, firstLine);
{ "name": "code-oss-dev", "version": "1.82.0", <del> "distro": "49cc0fbc0a8e222bcce2a7c3bf62e0d23f20d258", </del> <ins> "distro": "2100ad274ed566f978bb917f327b3d99f95d59f2", </ins> "author": { "name": "Microsoft Corporation" },
) { super(); this._register(Registry.as<IViewsRegistry>(Extensions.ViewsRegistry).registerViewWelcomeContent(TUNNEL_VIEW_ID, { <del> content: `No forwarded ports. Forward a port to access your running services locally.n[Forward a Port](command:${ForwardPortAction.INLINE_ID})`, </del> <ins> content: this.environmentService.remoteAuthority ? nls.localize('remoteNoPorts', "No forwarded ports. Forward a port to access your running services locally.n[Forward a Port]({0})", `command:${ForwardPortAction.INLINE_ID}`) : nls.localize('noRemoteNoPorts', "No forwarded ports. Forward a port to access your locally running services over the internet.n[Forward a Port]({0})", `command:${ForwardPortAction.INLINE_ID}`), </ins> })); this.enableBadgeAndStatusBar(); this.enableForwardedPortsView();
} # Set IsWindows property <del> [Console]::Write("$([char]0x1b)]633;P;IsWindows=$($IsWindows)`a") </del> <ins> if ($PSVersionTable.PSVersion -lt "6.0") { # Windows PowerShell is only available on Windows [Console]::Write("$([char]0x1b)]633;P;IsWindows=$true`a") } else { [Console]::Write("$([char]0x1b)]633;P;IsWindows=$IsWindows`a") } </ins> # Set always on key handlers which map to default VS Code keybindings function Set-MappedKeyHandler {
readonly raw: RawXtermTerminal; private _core: IXtermCore; private static _suggestedRendererType: 'canvas' | 'dom' | undefined = undefined; <ins> private static _checkedWebglCompatible = false; </ins> private _attached?: { container: HTMLElement; options: IXtermAttachToElementOptions }; private _isPhysicalMouseWheel = MouseWheelClassifier.INSTANCE.isPhysicalMouseWheel();
if (!this.raw.element || this._webglAddon) { return; } <ins> // Check if the the WebGL renderer is compatible with xterm.js: // - https://github.com/microsoft/vscode/issues/190195 // - https://github.com/xtermjs/xterm.js/issues/4665 // - https://bugs.chromium.org/p/chromium/issues/detail?id=1476475 if (!XtermTerminal._checkedWebglCompatible) { XtermTerminal._checkedWebglCompatible = true; const checkCanvas = document.createElement('canvas'); const checkGl = checkCanvas.getContext('webgl2'); const debugInfo = checkGl?.getExtension('WEBGL_debug_renderer_info'); if (checkGl && debugInfo) { const renderer = checkGl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL); if (renderer.startsWith('ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero)')) { this._disableWebglForThisSession(); return; } } } </ins> const Addon = await this._getWebglAddonConstructor(); this._webglAddon = new Addon(); this._disposeOfCanvasRenderer();
if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') { this._measureRenderTime(); } <del> XtermTerminal._suggestedRendererType = 'canvas'; this._disposeOfWebglRenderer(); this._enableCanvasRenderer(); </del> <ins> this._disableWebglForThisSession(); </ins> } } <ins> private _disableWebglForThisSession() { XtermTerminal._suggestedRendererType = 'canvas'; this._disposeOfWebglRenderer(); this._enableCanvasRenderer(); } </ins> private async _enableCanvasRenderer(): Promise<void> { if (!this.raw.element || this._canvasAddon) { return;
}); suite('renderers', () => { <del> test('should re-evaluate gpu acceleration auto when the setting is changed', async () => { </del> <ins> // This is skipped until the webgl renderer bug is fixed in Chromium // https://bugs.chromium.org/p/chromium/issues/detail?id=1476475 test.skip('should re-evaluate gpu acceleration auto when the setting is changed', async () => { </ins> // Check initial state strictEqual(TestWebglAddon.isEnabled, false);
*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { Disposable, MutableDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { Disposable, DisposableStore, MutableDisposable } from 'vs/base/common/lifecycle'; </ins> import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { ITerminalCapabilityStore, TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities'; import { ITerminalLogService } from 'vs/platform/terminal/common/terminal'; import type { Terminal, ITerminalAddon } from 'xterm'; <ins> import { debounce } from 'vs/base/common/decorators'; import { addDisposableListener } from 'vs/base/browser/dom'; </ins> export interface ITextAreaData { content: string;
export class TextAreaSyncAddon extends Disposable implements ITerminalAddon { private _terminal: Terminal | undefined; <del> private _onCursorMoveListener = this._register(new MutableDisposable()); </del> <ins> private _listeners = this._register(new MutableDisposable<DisposableStore>()); private _currentCommand: string | undefined; private _cursorX: number | undefined; </ins> activate(terminal: Terminal): void { this._terminal = terminal; if (this._accessibilityService.isScreenReaderOptimized()) { <del> this._onCursorMoveListener.value = this._terminal.onCursorMove(() => this._refreshTextArea()); </del> <ins> this._registerSyncListeners(); </ins> } }
getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection; } <del> export type EnvironmentVariableScope = { </del> <ins> /** * The scope object to which the environment variable collection applies. */ export interface EnvironmentVariableScope { </ins> /** * Any specific workspace folder to get collection for. */ workspaceFolder?: WorkspaceFolder; <del> }; </del> <ins> } </ins> /** * A location in the editor at which progress information can be shown. It depends on the
if (isNonEmptyArray(notification.actions && notification.actions.secondary)) { actions++; // secondary actions } <del> this.offsetHelper.style.width = `${450 /* notifications container width */ - (10 /* padding */ + 26 /* severity icon */ + (actions * (24 + 8)) /* 24px (+8px padding) per action */ - 4 /* 4px less padding for last action */)}px`; </del> <ins> this.offsetHelper.style.width = `${450 /* notifications container width */ - (10 /* padding */ + 30 /* severity icon */ + (actions * 30) /* actions */ - (Math.max(actions - 1, 0) * 4) /* less padding for actions > 1 */)}px`; </ins> // Render message into offset helper const renderedMessage = NotificationMessageRenderer.render(notification.message);
{ "name": "code-oss-dev", "version": "1.95.0", <del> "distro": "350f0404ef17accb38b1359e82886738870a7377", </del> <ins> "distro": "1f05cd9b265f2477905f0b7688a66cfb2c6061f5", </ins> "author": { "name": "Microsoft Corporation" },
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities'; import { TerminalCapabilityStore } from 'vs/platform/terminal/common/capabilities/terminalCapabilityStore'; <ins> import { formatMessageForTerminal } from 'vs/platform/terminal/common/terminalStrings'; </ins> import { IColorTheme, IThemeService } from 'vs/platform/theme/common/themeService'; import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { IViewPaneOptions, ViewPane } from 'vs/workbench/browser/parts/views/viewPane';
return this._scrollBeyondLastLine && !this.isEmbedded; } <ins> private getBodyHeight(dimensionHeight: number) { return Math.max(dimensionHeight - (this._notebookTopToolbar?.useGlobalToolbar ? /** Toolbar height */ 26 : 0), 0); } </ins> layout(dimension: DOM.Dimension, shadowElement?: HTMLElement, position?: DOM.IDomPosition): void { if (!shadowElement && this._shadowElementViewInfo === null) { this._dimension = dimension;
this._dimension = dimension; this._position = position; <del> const newBodyHeight = Math.max(dimension.height - (this._notebookTopToolbar?.useGlobalToolbar ? /** Toolbar height */ 26 : 0), 0); </del> <ins> const newBodyHeight = this.getBodyHeight(dimension.height); </ins> DOM.size(this._body, dimension.width, newBodyHeight); const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
} if (this._cursorX !== textArea.selectionStart) { <del> textArea.selectionStart = this._cursorX ?? 0; textArea.selectionEnd = this._cursorX ?? 0; this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${this._cursorX}`); </del> <ins> const selection = !this._cursorX || this._cursorX < 0 ? 0 : this._cursorX; textArea.selectionStart = selection; textArea.selectionEnd = selection; this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${selection}`); </ins> } }
handleCommandFinished(exitCode: number | undefined, options?: IHandleCommandOptions): void { if (this._isWindowsPty) { <del> this._preHandleCommandFinishedWindows(); </del> <ins> this._commandStartWindowsPromise?.then(() => this._preHandleCommandFinishedWindows()); </ins> } this._currentCommand.commandFinishedMarker = options?.marker || this._terminal.registerMarker(0);
@IKeybindingService private _keybindingService: IKeybindingService, @IInstantiationService private _instaService: IInstantiationService, ) { <del> super(undefined, _submenu.actions[0], options); </del> <ins> super(undefined, _submenu.actions.find(action => action.id === 'workbench.action.quickOpenWithModes') ?? _submenu.actions[0], options); </ins> } override render(container: HTMLElement): void {
}); <ins> const CONTEXT_TOOLBAR_COMMAND_CENTER = ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter'); </ins> MenuRegistry.appendMenuItem(MenuId.CommandCenterCenter, { submenu: MenuId.DebugToolBar, title: 'Debug', icon: Codicon.debug, order: 1, <del> when: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter')) </del> <ins> when: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_TOOLBAR_COMMAND_CENTER) </ins> }); registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, icons.debugContinue, CONTEXT_DEBUG_STATE.isEqualTo('stopped'));
registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, icons.debugRestart); registerDebugToolBarItem(STEP_BACK_ID, localize('stepBackDebug', "Step Back"), 50, icons.debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_DEBUG_STATE.isEqualTo('stopped')); registerDebugToolBarItem(REVERSE_CONTINUE_ID, localize('reverseContinue', "Reverse"), 55, icons.debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_DEBUG_STATE.isEqualTo('stopped')); <del> registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, CONTEXT_MULTI_SESSION_DEBUG); </del> <ins> registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, ContextKeyExpr.and(CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TOOLBAR_COMMAND_CENTER.negate())); </ins> MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, { group: 'navigation',
Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({ ...editorConfigurationBaseNode, properties: { <del> 'editor.codeActionWidget.includeNearbyQuickfixes': { </del> <ins> 'editor.codeActionWidget.includeNearbyQuickFixes': { </ins> type: 'boolean', scope: ConfigurationScope.LANGUAGE_OVERRIDABLE, <del> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), </del> <ins> description: nls.localize('includeNearbyQuickFixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), </ins> default: true, }, }
return { ahead: Number(ahead) || 0, behind: Number(behind) || 0 }; } <ins> async revParse(ref: string): Promise<string | undefined> { try { const result = await this.exec(['rev-parse', ref]); if (result.stderr) { return undefined; } return result.stdout.trim(); } catch (err) { return undefined; } } </ins> async updateSubmodules(paths: string[]): Promise<void> { const args = ['submodule', 'update'];
} const optionsRef = options.limit.id; <ins> const historyItemGroupIdRef = await this.repository.revParse(historyItemGroupId) ?? ''; </ins> const [commits, summary] = await Promise.all([ <del> this.repository.log({ range: `${optionsRef}..${historyItemGroupId}`, sortByAuthorDate: true }), this.getSummaryHistoryItem(optionsRef, historyItemGroupId) </del> <ins> this.repository.log({ range: `${optionsRef}..${historyItemGroupIdRef}`, sortByAuthorDate: true }), this.getSummaryHistoryItem(optionsRef, historyItemGroupIdRef) </ins> ]); const historyItems = commits.length === 0 ? [] : [summary];
GetBranchOperation | GetBranchesOperation | GetCommitTemplateOperation | GetObjectDetailsOperation | GetRefsOperation | GetRemoteRefsOperation | HashObjectOperation | IgnoreOperation | LogOperation | LogFileOperation | MergeOperation | MergeAbortOperation | MergeBaseOperation | MoveOperation | PostCommitCommandOperation | PullOperation | PushOperation | RemoteOperation | RenameBranchOperation | RemoveOperation | <del> ResetOperation | RebaseOperation | RebaseAbortOperation | RebaseContinueOperation | RevertFilesOperation | RevListOperation | </del> <ins> ResetOperation | RebaseOperation | RebaseAbortOperation | RebaseContinueOperation | RevertFilesOperation | RevListOperation | RevParseOperation | </ins> SetBranchUpstreamOperation | ShowOperation | StageOperation | StatusOperation | StashOperation | SubmoduleUpdateOperation | SyncOperation | TagOperation;
export type RebaseContinueOperation = BaseOperation & { kind: OperationKind.RebaseContinue }; export type RevertFilesOperation = BaseOperation & { kind: OperationKind.RevertFiles }; export type RevListOperation = BaseOperation & { kind: OperationKind.RevList }; <ins> export type RevParseOperation = BaseOperation & { kind: OperationKind.RevParse }; </ins> export type SetBranchUpstreamOperation = BaseOperation & { kind: OperationKind.SetBranchUpstream }; export type ShowOperation = BaseOperation & { kind: OperationKind.Show }; export type StageOperation = BaseOperation & { kind: OperationKind.Stage };
RebaseContinue: { kind: OperationKind.RebaseContinue, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as RebaseContinueOperation, RevertFiles: (showProgress: boolean) => ({ kind: OperationKind.RevertFiles, blocking: false, readOnly: false, remote: false, retry: false, showProgress } as RevertFilesOperation), RevList: { kind: OperationKind.RevList, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as RevListOperation, <ins> RevParse: { kind: OperationKind.RevParse, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as RevParseOperation, </ins> SetBranchUpstream: { kind: OperationKind.SetBranchUpstream, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as SetBranchUpstreamOperation, Show: { kind: OperationKind.Show, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as ShowOperation, Stage: { kind: OperationKind.Stage, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as StageOperation,
return await this.run(Operation.RevList, () => this.repository.getCommitCount(range)); } <ins> async revParse(ref: string): Promise<string | undefined> { return await this.run(Operation.RevParse, () => this.repository.revParse(ref)); } </ins> async reset(treeish: string, hard?: boolean): Promise<void> { await this.run(Operation.Reset, () => this.repository.reset(treeish, hard)); }
'editor.codeActionWidget.includeNearbyQuickfixes': { type: 'boolean', scope: ConfigurationScope.LANGUAGE_OVERRIDABLE, <del> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest quickfix within a line when not currently on a diagnostic."), default: false, </del> <ins> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), default: true, </ins> }, } });
return undefined; } <del> export function getSelectionTextFromEditor(allowUnselectedWord: boolean, editor: IEditor): string | null { </del> <ins> export function getSelectionTextFromEditor(allowUnselectedWord: boolean, activeEditor: IEditor): string | null { let editor = activeEditor; if (isDiffEditor(editor)) { if (editor.getOriginalEditor().hasTextFocus()) { editor = editor.getOriginalEditor(); } else { editor = editor.getModifiedEditor(); } } </ins> if (!isCodeEditor(editor) || !editor.hasModel()) { return null;
} private async _getMediaFilesEdit(document: vscode.TextDocument, dataTransfer: vscode.DataTransfer, token: vscode.CancellationToken): Promise<vscode.DocumentDropEdit | undefined> { <del> if (document.uri.scheme === Schemes.untitled) { </del> <ins> if (getParentDocumentUri(document.uri).scheme === Schemes.untitled) { </ins> return; }
import { Mime, mediaMimes } from '../../util/mimes'; import { Schemes } from '../../util/schemes'; import { PasteUrlAsFormattedLink, createEditAddingLinksForUriList, createEditForMediaFiles, getPasteUrlAsFormattedLinkSetting } from './shared'; <ins> import { getParentDocumentUri } from '../../util/document'; </ins> class PasteResourceEditProvider implements vscode.DocumentPasteEditProvider {
} private async _getMediaFilesEdit(document: vscode.TextDocument, dataTransfer: vscode.DataTransfer, token: vscode.CancellationToken): Promise<vscode.DocumentPasteEdit | undefined> { <del> if (document.uri.scheme === Schemes.untitled) { </del> <ins> if (getParentDocumentUri(document.uri).scheme === Schemes.untitled) { </ins> return; }
this._overlayContainer.style.position = 'absolute'; this._overlayContainer.style.overflow = 'hidden'; <del> if (this._isVisible) { this.layoutContainerOverShadowElement(dimension, position); } </del> <ins> this.layoutContainerOverShadowElement(dimension, position); </ins> if (this._webviewTransparentCover) { this._webviewTransparentCover.style.height = `${dimension.height}px`;
import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IOutlineModelService } from 'vs/editor/contrib/documentSymbols/browser/outlineModel'; import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures'; <ins> import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { accessibilityHelpIsShown, accessibleViewIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </ins> export class GotoSymbolQuickAccessProvider extends AbstractGotoSymbolQuickAccessProvider {