jiebi/CodeConvo huggingface dataset:
Change:
Checkout the screen capture below which shows totally broken views. Notice the view title in the bottom panel and the missing icon the secondary sidebar (in my setup the secondary sidebar is left, the primary is right). I suspect this is due to setting/view sync because I have connected a windows VM <img width="1494" alt="Screenshot 2024-01-23 at 12 10 56" src=""
Have you tried clicking on those broken views and found out what those views are?
Analysed the data provided by and this is what happened Windows machine has some obsolete custom view containers state (in pane composite bar) which we are not cleaning up . When sync started, this machine has pushed this state, for eg:Mac machine has accepted this state and started rendering this obsolete view container even though this does not exist. This seems to be a bug in pane composite bar that render view containers - it is rendering obsolete view containers placeholders even though they do not exists in the model.
verified by code review

Discussion:
name: cachedViewContainer.name, order: cachedViewContainer.order, pinned: cachedViewContainer.pinned, <del> visible: cachedViewContainer.visible, </del> <ins> visible: cachedViewContainer.visible && !!this.getViewContainer(cachedViewContainer.id), </ins> }); }
Change:
Testing open a multi repository workspace Unselect one repository in SCM repositories view Right click on unselected repository and choose Close other repositories action Nothing happens

Discussion:
const actions = collectContextMenuActions(menu); const actionRunner = this._register(new RepositoryActionRunner(() => { <del> const focusedRepositories = this.list.getFocusedElements(); const selectedRepositories = this.list.getSelectedElements(); return Array.from(new Set<ISCMRepository>([...focusedRepositories, ...selectedRepositories])); </del> <ins> return this.list.getSelectedElements(); </ins> })); actionRunner.onWillRun(() => this.list.domFocus());
Change:
Testing When both command center and actions are disabled for custom title, clicking this entry does nothing and gives no feedback: !

Discussion:
title: localize('toggle.customTitleBar', 'Custom Title Bar'), toggled: TitleBarVisibleContext, menu: [ <del> { id: MenuId.MenubarAppearanceMenu, order: 6, when: ContextKeyExpr.or(ContextKeyExpr.equals(TitleBarStyleContext.key, TitlebarStyle.NATIVE), IsMainWindowFullscreenContext), group: '2_workbench_layout' }, ] </del> <ins> { id: MenuId.MenubarAppearanceMenu, order: 6, when: ContextKeyExpr.or( ContextKeyExpr.and( ContextKeyExpr.equals(TitleBarStyleContext.key, TitlebarStyle.NATIVE), ContextKeyExpr.and( ContextKeyExpr.equals('config.workbench.layoutControl.enabled', false), ContextKeyExpr.equals('config.window.commandCenter', false), ContextKeyExpr.notEquals('config.workbench.editor.editorActionsLocation', 'titleBar'), ContextKeyExpr.notEquals('config.workbench.activityBar.location', 'top') )?.negate() ), IsMainWindowFullscreenContext ), group: '2_workbench_layout' }, ], </ins> }); }
Change:
Testing I noticed a difference in behavior. Not sure whether it's an issue. If I have a command that doesn't terminate, and I use , then I don't get a prompt after closing the editor until I ctrl+C. the editor that opens Insiders, I don't get back to the prompt until I ctrl+C in the terminal. But in stable, I do get back to the prompt at this point.
Yeah this is a good catch and it takes me a bit to understand what we should be doing here actually. I think: when is used, we should return prompt when files close (as we used to) without at least we should return prompt when the Code process terminates This "regressed" with us prolonging the CLI shutdown for as long as the piped process runs:
I decided to do 1) but not 2).

Discussion:
try { const readFromStdinDone = new DeferredPromise<void>(); await readFromStdin(stdinFilePath, !!args.verbose, () => readFromStdinDone.complete()); <del> processCallbacks.push(() => readFromStdinDone.p); </del> <ins> if (!args.wait) { // if `--wait` is not provided, we keep this process alive // for at least as long as the stdin stream is open to // ensure that we read all the data. // the downside is that the Code CLI process will then not // terminate until stdin is closed, but users can always // pass `--wait` to prevent that from happening (this is // actually what we enforced until v1.85.x but then was // changed to not enforce it anymore). // a solution in the future would possibly be to exit, when // the Code process exits. this would require some careful // solution though in case Code is already running and this // is a second instance telling the first instance what to // open. processCallbacks.push(() => readFromStdinDone.p); } </ins> // Make sure to open tmp file as editor but ignore it in the "recently open" list addArg(argv, stdinFilePath);
Change:
Testing Kept playing with "hey code", at one point the EH restarted (unsure why but likely due to speech). Anyways, the console showed the error below which likely means some didn't dispose something. Once you are in this state speech is broken
Steps open vscode, start speech F1 restart EH error shows, speech is broken
I always keep forgetting this in , we should probably have some kind of lint rule...

Discussion:
import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { Emitter } from 'vs/base/common/event'; <del> import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle'; </ins> import { ILogService } from 'vs/platform/log/common/log'; import { ExtHostContext, ExtHostSpeechShape, MainContext, MainThreadSpeechShape } from 'vs/workbench/api/common/extHost.protocol'; import { IKeywordRecognitionEvent, ISpeechProviderMetadata, ISpeechService, ISpeechToTextEvent } from 'vs/workbench/contrib/speech/common/speechService';

}; @extHostNamedCustomer(MainContext.MainThreadSpeech) <del> export class MainThreadSpeech extends Disposable implements MainThreadSpeechShape { </del> <ins> export class MainThreadSpeech implements MainThreadSpeechShape { </ins> private readonly proxy: ExtHostSpeechShape;

@ISpeechService private readonly speechService: ISpeechService, @ILogService private readonly logService: ILogService ) { <del> super(); </del> this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostSpeech); }

const providerSession = this.keywordRecognitionSessions.get(session); providerSession?.onDidChange.fire(event); } <ins> dispose(): void { this.providerRegistrations.forEach(disposable => disposable.dispose()); this.providerRegistrations.clear(); this.speechToTextSessions.forEach(session => session.onDidChange.dispose()); this.speechToTextSessions.clear(); this.keywordRecognitionSessions.forEach(session => session.onDidChange.dispose()); this.keywordRecognitionSessions.clear(); } </ins> }
Change:
Got the trace below, this happens when PAUSE is enter as part of error handling which then also errors...
The error leading up to this is:
To verify start inline chat get it to make changes select ESC to hide inline chat select cmd+i to start inline chat again

Discussion:
} this._historyOffset = -1; this._historyCandidate = ''; <ins> this._stashedSession.clear(); </ins> this._onWillStartSession.fire(); this._currentRun = this._nextState(State.CREATE_SESSION, options); await this._currentRun;

} private async[State.PAUSE]() { <del> assertType(this._session); assertType(this._strategy); </del> this._resetWidget(); <del> this._strategy.pause?.(); </del> <ins> this._strategy?.pause?.(); </ins> this._session = undefined; }
Change:
Testing Disable autosave Open a file, make some change, don't save Open a stash in multi-file diff editor The diff editor is marked as unsaved and I can't close it at all If I close the original editor, the multi file diff can be closed !
could you please take a look at this one. Thanks!

Discussion:
import { IResolvedTextEditorModel, ITextModelService } from 'vs/editor/common/services/resolverService'; import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration'; import { localize } from 'vs/nls'; <ins> import { ConfirmResult } from 'vs/platform/dialogs/common/dialogs'; </ins> import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { IEditorConfiguration } from 'vs/workbench/browser/parts/editor/textEditor'; import { DEFAULT_EDITOR_ASSOCIATION, EditorInputCapabilities, EditorInputWithOptions, IEditorSerializer, IResourceMultiDiffEditorInput, ISaveOptions, IUntypedEditorInput } from 'vs/workbench/common/editor'; <del> import { EditorInput } from 'vs/workbench/common/editor/editorInput'; </del> <ins> import { EditorInput, IEditorCloseHandler } from 'vs/workbench/common/editor/editorInput'; </ins> import { MultiDiffEditorIcon } from 'vs/workbench/contrib/multiDiffEditor/browser/icons.contribution'; import { ConstResolvedMultiDiffSource, IMultiDiffSourceResolverService, IResolvedMultiDiffSource, MultiDiffEditorItem } from 'vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService'; import { ObservableLazyStatefulPromise } from 'vs/workbench/contrib/multiDiffEditor/browser/utils';

} return undefined; } <ins> override readonly closeHandler: IEditorCloseHandler = { async confirm() { return ConfirmResult.DONT_SAVE; }, showConfirm() { return false; } }; </ins> } function isUriDirty(textFileService: ITextFileService, uri: URI) {
Change:
Testing "Audio Cues: Line Has Warning" is set to false. "Accessibility Alert: Warning" is set to true. I generated a warning by using the Markdown Lint extension and writing text into a new Markdown file without an h1 header. When I turn on the audio cue, the accessibility alert also alerts me that there's a warning. When I turn off the audio cue but leave the accessibility alert on, the accessibility alert does not alert me that there's a warning.
I cannot seem to trigger a warning - can you pls give more specific instructions about how to do so? !
Install the extension. Then create a .md file and paste in the following The extension should already generate a warning.
Note this issue when verifying . When I tested using a screen reader, the warning only appeared once. Based on debugging (the call happens), I believe when using a braille device, this works.

Discussion:
return Event.None; } <ins> onAlertEnabledChanged(cue: AudioCue): Event<void> { return Event.None; } </ins> async playSound(cue: Sound, allowManyInParallel?: boolean | undefined): Promise<void> { } playAudioCueLoop(cue: AudioCue): IDisposable {

isCueEnabled(cue: AudioCue): boolean; isAlertEnabled(cue: AudioCue): boolean; onEnabledChanged(cue: AudioCue): Event<void>; <ins> onAlertEnabledChanged(cue: AudioCue): Event<void>; </ins> playSound(cue: Sound, allowManyInParallel?: boolean): Promise<void>; playAudioCueLoop(cue: AudioCue, milliseconds: number): IDisposable;

public onEnabledChanged(cue: AudioCue): Event<void> { return Event.fromObservableLight(this.isCueEnabledCache.get({ cue })); } <ins> public onAlertEnabledChanged(cue: AudioCue): Event<void> { return Event.fromObservableLight(this.isAlertEnabledCache.get({ cue })); } </ins> }

() => this.audioCueService.isCueEnabled(cue) )); <ins> private readonly isAlertEnabledCache = new CachedFunction<AudioCue, IObservable<boolean>>((cue) => observableFromEvent( this.audioCueService.onAlertEnabledChanged(cue), () => this.audioCueService.isAlertEnabled(cue) )); </ins> constructor( @IEditorService private readonly editorService: IEditorService, @IInstantiationService private readonly instantiationService: IInstantiationService,

const someAudioCueFeatureIsEnabled = derived( (reader) => /** @description someAudioCueFeatureIsEnabled */ this.features.some((feature) => <del> this.isEnabledCache.get(feature.audioCue).read(reader) </del> <ins> this.isEnabledCache.get(feature.audioCue).read(reader) || this.isAlertEnabledCache.get(feature.audioCue).read(reader) </ins> ) );

const isFeaturePresent = derivedOpts( { debugName: `isPresentInLine:${feature.audioCue.name}` }, (reader) => { <del> if (!this.isEnabledCache.get(feature.audioCue).read(reader)) { </del> <ins> if (!this.isEnabledCache.get(feature.audioCue).read(reader) && !this.isAlertEnabledCache.get(feature.audioCue).read(reader)) { </ins> return false; } const position = debouncedPosition.read(reader);
Change:
Type: <bBug</ba readonly file system opening a file that does not exist. You can use the command for this bug A diaglogdialog shows that includes an option for <img width="345" alt="Screenshot 2024-01-23 at 10 38 49 AM" src=""Clicking on this option shows a second dialog that says the file cannot be created: <img width="312" alt="Screenshot 2024-01-23 at 10 39 02 AM" src=""I think it would be better not to show file in the first dialog VS Code version: Code - Insiders 1.86.0-insider (Universal) (, 2024-01-23T06:13:09.134Z) OS version: Darwin arm64 23.2.0 Modes: <details<summarySystem Info</summary </details<!-- generated by issue reporter --

Discussion:
import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences'; import { IHostService } from 'vs/workbench/services/host/browser/host'; import { IEditorOptions as ICodeEditorOptions } from 'vs/editor/common/config/editorOptions'; <ins> import { IFilesConfigurationService } from 'vs/workbench/services/filesConfiguration/common/filesConfigurationService'; </ins> /** * An implementation of editor for file system resources.

@IPathService private readonly pathService: IPathService, @IConfigurationService private readonly configurationService: IConfigurationService, @IPreferencesService protected readonly preferencesService: IPreferencesService, <del> @IHostService private readonly hostService: IHostService </del> <ins> @IHostService private readonly hostService: IHostService, @IFilesConfigurationService private readonly filesConfigurationService: IFilesConfigurationService </ins> ) { super(TextFileEditor.ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);

throw createTooLargeFileError(this.group, input, options, message, this.preferencesService); } <del> // Offer to create a file from the error if we have a file not found and the name is valid if ((<FileOperationError>error).fileOperationResult === FileOperationResult.FILE_NOT_FOUND && await this.pathService.hasValidBasename(input.preferredResource)) { </del> <ins> // Offer to create a file from the error if we have a file not found and the name is valid and not readonly if ( (<FileOperationError>error).fileOperationResult === FileOperationResult.FILE_NOT_FOUND && !this.filesConfigurationService.isReadonly(input.preferredResource) && await this.pathService.hasValidBasename(input.preferredResource) ) { </ins> const fileNotFoundError = createEditorOpenError(new FileOperationError(localize('unavailableResourceErrorEditorText', "The editor could not be opened because the file was not found."), FileOperationResult.FILE_NOT_FOUND), [ toAction({ id: 'workbench.files.action.createMissingFile', label: localize('createFile', "Create File"), run: async () => {
Change:
Testing It seems weird to pass in string when you could just pass in a Uri. Better yet, consider
I think when I was testing, URI wasn't serializable so it wouldn't be passed thru the command properly - will double check this soon though
you may need to turn it into a and then that on the other end. It's possible. We do it with other processes.

Discussion:
<span id="ext-loading" hidden></span> <span class="ext-parens" hidden>(</span><a href="#" class="showInfo" id="extension-id">${escape(localize('show', "show"))}</a><span class="ext-parens" hidden>)</span> </label> <del> <pre class="block-info" id="extension-data" placeholder="${escape(localize('extensionData', "Extension does not have additional data to include."))}"> </del> <ins> <pre class="block-info" id="extension-data" placeholder="${escape(localize('extensionData', "Extension does not have additional data to include."))}" style="white-space: pre-wrap;"> </ins> <!-- To be dynamically filled --> </pre> </div>

import { isLinuxSnap, isMacintosh } from 'vs/base/common/platform'; import { escape } from 'vs/base/common/strings'; import { ThemeIcon } from 'vs/base/common/themables'; <ins> import { URI } from 'vs/base/common/uri'; </ins> import { IssueReporterModel, IssueReporterData as IssueReporterModelData } from 'vs/code/electron-sandbox/issue/issueReporterModel'; import { localize } from 'vs/nls'; import { isRemoteDiagnosticError } from 'vs/platform/diagnostics/common/diagnostics';

private async updateIssueReporterUri(extension: IssueReporterExtensionData): Promise<void> { try { if (extension.command?.uri) { <del> extension.bugsUrl = extension.command.uri; </del> <ins> const uri = URI.revive(extension.command.uri); extension.bugsUrl = uri.toString(); </ins> } else { const uri = await this.issueMainService.$getIssueReporterUri(extension.id); extension.bugsUrl = uri.toString(true);

} if (selectedExtension?.command?.uri) { <del> issueUrl = selectedExtension.command.uri; </del> <ins> const uri = URI.revive(selectedExtension.command.uri); issueUrl = uri.toString(); </ins> } const gitHubDetails = this.parseGitHubUrl(issueUrl);

*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { URI } from 'vs/base/common/uri'; </del> <ins> import { URI, UriComponents } from 'vs/base/common/uri'; </ins> import { ISandboxConfiguration } from 'vs/base/parts/sandbox/common/sandboxTypes'; import { PerformanceInfo, SystemInfo } from 'vs/platform/diagnostics/common/diagnostics'; import { createDecorator } from 'vs/platform/instantiation/common/instantiation';

command?: { data?: string; template?: string; <del> uri?: string; </del> <ins> uri?: UriComponents; </ins> }; }
Change:
Testing I really like this new mode. One thing that I noticed at least while I was testing was that the "listening indicator" appeared below the code selection, but when the recording completed, inline chat appeared above the code selection. I think that it would be nice if both UI elements would use the same anchor location.
Today the indicator appears at the active end of the selection (where the cursor is) and it positions itself so that it doesn't cover the selection. This might be too much and we can simply use the selection start and always show above that.

Discussion:
return null; } const selection = this._editor.getSelection(); <del> // const position = this._editor.getPosition(); </del> return { <del> position: selection.getPosition(), preference: [ selection.getPosition().equals(selection.getStartPosition()) ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW, ContentWidgetPositionPreference.EXACT ] </del> <ins> position: selection.getStartPosition(), preference: [ContentWidgetPositionPreference.ABOVE, ContentWidgetPositionPreference.EXACT] </ins> }; }
Change:
Testing an empty commit Notice the action still appears even though it's a no-op. We should either hide it (preferable) or disable it. <img width="568" alt="image" src=""

Discussion:
"scm/incomingChanges/allChanges/context": [ { "command": "git.viewAllChanges", <del> "when": "scmProvider == git && config.multiDiffEditor.experimental.enabled", </del> <ins> "when": "scmProvider == git && scmHistoryItemFileCount != 0 && config.multiDiffEditor.experimental.enabled", </ins> "group": "inline@1" } ], "scm/incomingChanges/historyItem/context": [ { "command": "git.viewCommit", <del> "when": "scmProvider == git && config.multiDiffEditor.experimental.enabled", </del> <ins> "when": "scmProvider == git && scmHistoryItemFileCount != 0 && config.multiDiffEditor.experimental.enabled", </ins> "group": "inline@1" } ],

"scm/outgoingChanges/allChanges/context": [ { "command": "git.viewAllChanges", <del> "when": "scmProvider == git && config.multiDiffEditor.experimental.enabled", </del> <ins> "when": "scmProvider == git && scmHistoryItemFileCount != 0 && config.multiDiffEditor.experimental.enabled", </ins> "group": "inline@1" } ], "scm/outgoingChanges/historyItem/context": [ { "command": "git.viewCommit", <del> "when": "scmProvider == git && config.multiDiffEditor.experimental.enabled", </del> <ins> "when": "scmProvider == git && scmHistoryItemFileCount != 0 && config.multiDiffEditor.experimental.enabled", </ins> "group": "inline@1" } ],

MenuId.SCMOutgoingChangesHistoryItemContext; } <del> result = this.menuService.createMenu(menuId, this.contextKeyService); </del> <ins> const contextKeyService = this.contextKeyService.createOverlay([ ['scmHistoryItemFileCount', historyItem.statistics?.files ?? 0], ]); result = this.menuService.createMenu(menuId, contextKeyService); </ins> this.historyItemMenus.set(historyItem, result); }
Change:
Testing the action on a commit in incoming/outgoing. Notice the SCM view shows progress. If there's any progress at all to show, it should be in the multi-file diff editor that opens, not SCM. This is very noticeable in empty commits, where clicking the action does nothing other than showing a progress bar. Related to

Discussion:
DeleteRef: { kind: OperationKind.DeleteRef, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as DeleteRefOperation, DeleteRemoteTag: { kind: OperationKind.DeleteRemoteTag, blocking: false, readOnly: false, remote: true, retry: false, showProgress: true } as DeleteRemoteTagOperation, DeleteTag: { kind: OperationKind.DeleteTag, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as DeleteTagOperation, <del> Diff: { kind: OperationKind.Diff, blocking: false, readOnly: true, remote: false, retry: false, showProgress: true } as DiffOperation, </del> <ins> Diff: { kind: OperationKind.Diff, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as DiffOperation, </ins> Fetch: (showProgress: boolean) => ({ kind: OperationKind.Fetch, blocking: false, readOnly: false, remote: true, retry: true, showProgress } as FetchOperation), FindTrackingBranches: { kind: OperationKind.FindTrackingBranches, blocking: false, readOnly: true, remote: false, retry: false, showProgress: true } as FindTrackingBranchesOperation, GetBranch: { kind: OperationKind.GetBranch, blocking: false, readOnly: true, remote: false, retry: false, showProgress: true } as GetBranchOperation,