jiebi/CodeConvo huggingface dataset:
Change:
[ ] Notebooks (.ipynb files) [X] Interactive Window and/or Cell Scripts (.py files with #%% markers) When rendering large output, I now get the option to at the bottom of the output in addition to the previous "text editor" view. However, when selecting this option, the full output is not rendered in the scrollable element. Instead, the ellipsis shown in the truncated view remain. The expected outcome would be that the content shown in the scrollable element would be the full output, not the truncated output. When changing the setting , the scrollable element is displayed immediately and shows the content as expected. To reproduce: Initial output: ! Output after clicking : ! Output when setting : ! 78.2 v2023.4. Python v3.8.13 No response No response Local

Discussion:
const text = outputInfo.text(); const outputScrolling = scrollingEnabled(outputInfo, ctx.settings); <del> const content = createOutputContent(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, false); </del> <ins> const content = createOutputContent(outputInfo.id, [text], ctx.settings.lineLimit, outputScrolling, false); </ins> content.classList.add('output-plaintext'); if (ctx.settings.outputWordWrap) { content.classList.add('word-wrap');
Change:
<!-- Do Not Delete This! bugreporttemplate --<!-- Please read our Rules of Conduct: --<!-- Read our guide about submitting issues: --<!-- Search existing issues to avoid creating duplicates. --<!-- Test using the latest Insiders build to see if your issue has already been fixed: --<!-- Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. --<!-- Launch with to check. --Does this issue occur when all extensions are disabled?: Yes <!-- If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. --<!-- Issues caused by an extension need to be reported directly to the extension publisher. The 'Help Report Issue' dialog can assist with this. --- VS Code Version: 1.78.2 OS Version: Windows 11 22H2 (.1778) Steps to Reproduce: ! a WSL folder from the command line with the argument --remote, with a trailing forward slash. Example: to search all files for any search term. The files will not appear. ! a WSL folder from the command line with the argument --remote, without a trailing forward slash. Example: to search all files for any search term. The files will appear. !

Discussion:
export class FolderMatchWithResource extends FolderMatch { <ins> protected _normalizedResource: Lazy<URI>; </ins> constructor(_resource: URI, _id: string, _index: number, _query: ITextQuery, _parent: SearchResult | FolderMatch, _searchModel: SearchModel, _closestRoot: FolderMatchWorkspaceRoot | null, @IReplaceService replaceService: IReplaceService, @IInstantiationService instantiationService: IInstantiationService,

@IUriIdentityService uriIdentityService: IUriIdentityService ) { super(_resource, _id, _index, _query, _parent, _searchModel, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService); <ins> this._normalizedResource = new Lazy(() => this.uriIdentityService.extUri.removeTrailingPathSeparator(this.uriIdentityService.extUri.normalizePath( this.resource))); </ins> } override get resource(): URI { return this._resource!; } <ins> get normalizedResource(): URI { return this._normalizedResource.value; } </ins> } /**

} const fileMatchParentParts: URI[] = []; <del> const normalizedResource = this.uriIdentityService.extUri.normalizePath(this.resource); </del> let uri = this.normalizedUriParent(rawFileMatch.resource); <del> while (!this.uriEquals(normalizedResource, uri)) { </del> <ins> while (!this.uriEquals(this.normalizedResource, uri)) { </ins> fileMatchParentParts.unshift(uri); const prevUri = uri; <del> uri = this.normalizedUriParent(uri); </del> <ins> uri = this.uriIdentityService.extUri.removeTrailingPathSeparator(this.normalizedUriParent(uri)); </ins> if (this.uriEquals(prevUri, uri)) { <del> throw Error(`${rawFileMatch.resource} is not correctly configured as a child of ${normalizedResource}`); </del> <ins> throw Error(`${rawFileMatch.resource} is not correctly configured as a child of ${this.normalizedResource}`); </ins> } }
Change:
Running can block the VS Code update on Windows as it prevents deleting the parent folder. The updater needs a way to terminate it, and a mutex to know that it needs to be terminated.

Discussion:
AppMutex: product.win32MutexName, TunnelMutex: product.win32TunnelMutex, TunnelServiceMutex: product.win32TunnelServiceMutex, <ins> TunnelApplicationName: product.tunnelApplicationName, </ins> ApplicationName: product.applicationName, Arch: arch, AppId: { 'ia32': ia32AppId, 'x64': x64AppId, 'arm64': arm64AppId }[arch],

end; end; <del> if IsNotBackgroundUpdate() and CheckForMutexes('{#TunnelMutex}') then begin MsgBox('{#NameShort} is still running a tunnel. Please stop the tunnel before installing.', mbInformation, MB_OK); Result := false end; </del> end; function WizardNotSilent(): Boolean;

var ShouldRestartTunnelService: Boolean; <ins> function StopTunnelOtherProcesses(): Boolean; var WaitCounter: Integer; TaskKilled: Integer; begin Log('Stopping all tunnel services (at ' + ExpandConstant('"{app}bin{#TunnelApplicationName}.exe"') + ')'); ShellExec('', 'powershell.exe', '-Command "Get-WmiObject Win32_Process | Where-Object { $_.ExecutablePath -eq ' + ExpandConstant('''{app}bin{#TunnelApplicationName}.exe''') + ' } | Select @{Name=''Id''; Expression={$_.ProcessId}} | Stop-Process -Force"', '', SW_HIDE, ewWaitUntilTerminated, TaskKilled) WaitCounter := 10; while (WaitCounter > 0) and CheckForMutexes('{#TunnelMutex}') do begin Log('Tunnel process is is still running, waiting'); Sleep(500); WaitCounter := WaitCounter - 1 end; if CheckForMutexes('{#TunnelMutex}') then begin Log('Unable to stop tunnel processes'); Result := False; end else Result := True; end; </ins> procedure StopTunnelServiceIfNeeded(); var StopServiceResultCode: Integer;

begin if IsNotBackgroundUpdate() then StopTunnelServiceIfNeeded(); <del> Result := '' </del> <ins> if IsNotBackgroundUpdate() and not StopTunnelOtherProcesses() then Result := '{#NameShort} is still running a tunnel process. Please stop the tunnel before installing.' else Result := ''; </ins> end; // VS Code will create a flag file before the update starts (/update=C:foobar)

#endif Exec(ExpandConstant('{sys}icacls.exe'), ExpandConstant('"{app}" /inheritancelevel:r ') + Permissions, '', SW_HIDE, ewWaitUntilTerminated, ResultCode); <del> end; </del>  No newline at end of file <ins> end; </ins>
Change:
Now that the web uses resolvers too, I think we want to remove the special handling for the remote indicator label. When a remoteAuthority is set, use the label formatter for the host name. As always, web embedders can control the remote indicator by defining the property in the embedder API. If they don't set it, they get the host label defined by our resource label providers. I checked that this does not impact Codespaces (uses windowIndicator) and (serverless, no remoteAuthority)

Discussion:
} // Show for remote windows on the desktop, but not when in code server web <del> if (this.remoteAuthority && (!isWeb || this.environmentService.options?.webSocketFactory)) { </del> <ins> if (this.remoteAuthority) { </ins> const hostLabel = this.labelService.getHostLabel(Schemas.vscodeRemote, this.remoteAuthority) || this.remoteAuthority; switch (this.connectionState) { case 'initializing':
Change:
Testing Open a folder that has a image in an empty profile Install Luna Paint Extension Edit the image using Luna Paint and do not save Switch the profile to another profile Reason is empty <img width="573" alt="image" src=""
Good catch, there is an error thrown but I fail to remember the reason in that case. It should be: !

Discussion:
*--------------------------------------------------------------------------------------------*/ import { Barrier } from 'vs/base/common/async'; <ins> import { toErrorMessage } from 'vs/base/common/errorMessage'; </ins> import { Emitter } from 'vs/base/common/event'; import { Disposable } from 'vs/base/common/lifecycle'; import { Schemas } from 'vs/base/common/network';

private async _doStopExtensionHostsWithVeto(reason: string): Promise<boolean> { const vetos: (boolean | Promise<boolean>)[] = []; <del> const vetoReasons: string[] = []; </del> <ins> const vetoReasons = new Set<string>(); </ins> this._onWillStop.fire({ reason,

if (typeof value === 'boolean') { if (value === true) { <del> vetoReasons.push(reason); </del> <ins> vetoReasons.add(reason); </ins> } } else { value.then(value => { if (value) { <del> vetoReasons.push(reason); </del> <ins> vetoReasons.add(reason); </ins> } <ins> }).catch(error => { vetoReasons.add(nls.localize('extensionStopVetoError', "{0} (Error: {1})", reason, toErrorMessage(error))); </ins> }); } }

if (!veto) { this._doStopExtensionHosts(); } else { <del> this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasons.join(', ')})`); </del> <ins> const vetoReasonsArray = Array.from(vetoReasons); this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`); </ins> await this._dialogService.warn( nls.localize('extensionStopVetoMessage', "The following operation was blocked: {0}", reason), <del> vetoReasons.length === 1 ? nls.localize('extensionStopVetoDetailsOne', "The reason for blocking the operation: {0}", vetoReasons[0]) : nls.localize('extensionStopVetoDetailsMany', "The reasons for blocking the operation:n- {0}", vetoReasons.join('n -')), </del> <ins> vetoReasonsArray.length === 1 ? nls.localize('extensionStopVetoDetailsOne', "The reason for blocking the operation: {0}", vetoReasonsArray[0]) : nls.localize('extensionStopVetoDetailsMany', "The reasons for blocking the operation:n- {0}", vetoReasonsArray.join('n -')), </ins> ); }
Change:
I end up with all my repositories selected when going into an empty profile and out again: !
we figured out together that this reproduces easily by running the command to restart the extension host while having 1 repository selected. The underlying issue is that there are events fired from the extension host being disposed. This somehow has an impact on the state of the selected repositories and should probably be ignored or handled differently.

Discussion:
import { binarySearch } from 'vs/base/common/arrays'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; <ins> import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; </ins> function getProviderStorageKey(provider: ISCMProvider): string { return `${provider.contextValue}:${provider.label}${provider.rootUri ? `:${provider.rootUri.toString()}` : ''}`;

constructor( @ISCMService scmService: ISCMService, @IContextKeyService contextKeyService: IContextKeyService, <ins> @IExtensionService extensionService: IExtensionService, </ins> @IInstantiationService instantiationService: IInstantiationService, @IConfigurationService private readonly configurationService: IConfigurationService, @IStorageService private readonly storageService: IStorageService,

} storageService.onWillSaveState(this.onWillSaveState, this, this.disposables); <ins> // Maintain repository selection when the extension host restarts. // Extension host is restarted after installing an extension update // or during a profile switch. extensionService.onWillStop(() => { this.onWillSaveState(); this.didFinishLoading = false; }, this, this.disposables); </ins> } private onDidAddRepository(repository: ISCMRepository): void {

let removed: Iterable<ISCMRepository> = Iterable.empty(); <del> if (this.previousState) { </del> <ins> if (this.previousState && !this.didFinishLoading) { </ins> const index = this.previousState.all.indexOf(getProviderStorageKey(repository.provider)); if (index === -1) {

const all = this.repositories.map(r => getProviderStorageKey(r.provider)); const visible = this.visibleRepositories.map(r => all.indexOf(getProviderStorageKey(r.provider))); <del> const raw = JSON.stringify({ all, sortKey: this._repositoriesSortKey, visible }); </del> <ins> this.previousState = { all, sortKey: this._repositoriesSortKey, visible }; </ins> <del> this.storageService.store('scm:view:visibleRepositories', raw, StorageScope.WORKSPACE, StorageTarget.MACHINE); </del> <ins> this.storageService.store('scm:view:visibleRepositories', JSON.stringify(this.previousState), StorageScope.WORKSPACE, StorageTarget.MACHINE); </ins> } @debounce(5000)

} this.didFinishLoading = true; <del> this.previousState = undefined; </del> } dispose(): void {
Change:
Testing microsoft/vscode-python Here: !
ideas on this? I provided the path to the file so the "Go to test..." works ( confirm if this is not the case). Thanks!
This works fine via double click but for example does not open on macOS. This works in other trees as standard gesture to open. To make this easy to adopt for trees, I think we have a convention in custom trees, not sure if they are used here. do you remember?
Yes, if you set the command of the tree item in extension provided trees to or then we do some magic and respect the arguments to those commands as outlined at and also respect things like double click and ctrl+click. Here is how we pass the click properties to those commands:

Discussion:
@ITestingPeekOpener private readonly peekOpener: ITestingPeekOpener, @ITestProfileService private readonly testProfileService: ITestProfileService, @ITestingContinuousRunService private readonly crService: ITestingContinuousRunService, <ins> @ICommandService commandService: ICommandService, </ins> ) { super();

testService.excluded.onTestExclusionsChanged, )(this.tree.refilter, this.tree)); <ins> this._register(this.tree.onMouseDblClick(e => { if (e.element instanceof TestItemTreeElement && !e.element.children.size && e.element.test.item.uri) { commandService.executeCommand('vscode.revealTest', e.element.test.item.extId); } })); </ins> this._register(this.tree); this._register(this.onChangeWelcomeVisibility(e => {
Change:
Testing microsoft/vscode-python Here: !
ideas on this? I provided the path to the file so the "Go to test..." works ( confirm if this is not the case). Thanks!
This works fine via double click but for example does not open on macOS. This works in other trees as standard gesture to open. To make this easy to adopt for trees, I think we have a convention in custom trees, not sure if they are used here. do you remember?
Yes, if you set the command of the tree item in extension provided trees to or then we do some magic and respect the arguments to those commands as outlined at and also respect things like double click and ctrl+click. Here is how we pass the click properties to those commands:

Discussion:
keyboardNavigationLabelProvider: instantiationService.createInstance(TreeKeyboardNavigationLabelProvider), accessibilityProvider: instantiationService.createInstance(ListAccessibilityProvider), filter: this.filter, <del> findWidgetEnabled: false </del> <ins> findWidgetEnabled: false, openOnSingleClick: false, </ins> }) as TestingObjectTree<FuzzyScore>;

testService.excluded.onTestExclusionsChanged, )(this.tree.refilter, this.tree)); <del> this._register(this.tree.onMouseDblClick(e => { </del> <ins> this._register(this.tree.onDidOpen(e => { </ins> if (e.element instanceof TestItemTreeElement && !e.element.children.size && e.element.test.item.uri) { commandService.executeCommand('vscode.revealTest', e.element.test.item.extId); }
Change:
extension details page for GitHub Repositories extension in :bug: the marketplace and repository links aren't shown !

Discussion:
// Check for updates this.eventuallyCheckForUpdates(true); <del> // Always auto update builtin extensions in web if (isWeb && !this.isAutoUpdateEnabled()) { this.autoUpdateBuiltinExtensions(); </del> <ins> if (isWeb) { this.syncPinnedBuiltinExtensions(); // Always auto update builtin extensions in web if (!this.isAutoUpdateEnabled()) { this.autoUpdateBuiltinExtensions(); } </ins> } }

// Skip if check updates only for builtin extensions and current extension is not builtin. continue; } <del> if (installed.isBuiltin && (installed.type === ExtensionType.System || !installed.local?.identifier.uuid)) { </del> <ins> if (installed.isBuiltin && !installed.pinned && (installed.type === ExtensionType.System || !installed.local?.identifier.uuid)) { </ins> // Skip checking updates for a builtin extension if it is a system extension or if it does not has Marketplace identifier continue; }

await Promises.settled(toUpdate.map(e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true } : undefined))); } <ins> private async syncPinnedBuiltinExtensions(): Promise<void> { const infos: IExtensionInfo[] = []; for (const installed of this.local) { if (installed.isBuiltin && installed.pinned && installed.local?.identifier.uuid) { infos.push({ ...installed.identifier, version: installed.version }); } } if (infos.length) { const galleryExtensions = await this.galleryService.getExtensions(infos, CancellationToken.None); if (galleryExtensions.length) { await this.syncInstalledExtensionsWithGallery(galleryExtensions); } } } </ins> private autoUpdateExtensions(): Promise<any> { if (!this.isAutoUpdateEnabled()) { return Promise.resolve();

if (webExtension) { result.set(galleryExtension.identifier.id.toLowerCase(), { ...webExtension, <ins> identifier: { id: webExtension.identifier.id, uuid: galleryExtension.identifier.uuid }, </ins> readmeUri: galleryExtension.assets.readme ? URI.parse(galleryExtension.assets.readme.uri) : undefined, changelogUri: galleryExtension.assets.changelog ? URI.parse(galleryExtension.assets.changelog.uri) : undefined, <del> metadata: { isPreReleaseVersion: galleryExtension.properties.isPreReleaseVersion, preRelease: galleryExtension.properties.isPreReleaseVersion, isBuiltin: true } </del> <ins> metadata: { isPreReleaseVersion: galleryExtension.properties.isPreReleaseVersion, preRelease: galleryExtension.properties.isPreReleaseVersion, isBuiltin: true, pinned: true } </ins> }); } }
Change:
In Dark Modern it's hard to tell what is hovered. Since there's an extremely subtle hover decoration, it looks like something is missing. I like the blue background in Dark+ !
This looks like it's caused by the settings dropdown list background color unintentionally being too light. Updated to match other list widgets: <img width="443" alt="CleanShot 2023-06-07 at 14 45 41 src=""<img width="340" alt="CleanShot 2023-06-07 at 14 45 50 src=""

Discussion:
"dropdown.background": "#313131", "dropdown.border": "#ffffff1f", "dropdown.foreground": "#cccccc", <del> "dropdown.listBackground": "#313131", </del> <ins> "dropdown.listBackground": "#1f1f1f", </ins> "editor.background": "#1f1f1f", "editor.findMatchBackground": "#9e6a03", "editor.foreground": "#cccccc",
Change:
Testing When I try to return , , and aren't working for me. an extension as described in and create a ports attribute provider. the following to return one of the above actions: running the command, we just get a notification. :bug: I'm not sure whether this is happening because I'm in a devcontainer.
Hmm, I'm still seeing this in an alpine devcontainer. The previews/browsers should open immediately upon detection, right?
Verified using different verif steps than above.

Discussion:
export class PortAttributes { private _autoForwardAction: PortAutoForwardAction; <del> constructor(autoForwardAction: PortAutoForwardAction); constructor(port: number, autoForwardAction: PortAutoForwardAction); constructor(portOrAction: number | PortAutoForwardAction, autoForwardAction?: PortAutoForwardAction) { if (typeof portOrAction === 'number') { this._autoForwardAction = autoForwardAction!; } else { this._autoForwardAction = portOrAction; } </del> <ins> constructor(autoForwardAction: PortAutoForwardAction) { this._autoForwardAction = autoForwardAction; </ins> } get autoForwardAction(): PortAutoForwardAction {

const matchingCandidates: Map<number, CandidatePort> = new Map(); const pidToPortsMapping: Map<number | undefined, number[]> = new Map(); forwardedPorts.forEach(forwardedPort => { <del> const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces<CandidatePort>(this._candidates ?? new Map(), LOCALHOST_ADDRESSES[0], forwardedPort.port); </del> <ins> const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces<CandidatePort>(this._candidates ?? new Map(), LOCALHOST_ADDRESSES[0], forwardedPort.port) ?? forwardedPort; </ins> if (matchingCandidate) { matchingCandidates.set(forwardedPort.port, matchingCandidate); <del> if (!pidToPortsMapping.has(matchingCandidate.pid)) { pidToPortsMapping.set(matchingCandidate.pid, []); </del> <ins> const pid = isCandidatePort(matchingCandidate) ? matchingCandidate.pid : undefined; if (!pidToPortsMapping.has(pid)) { pidToPortsMapping.set(pid, []); </ins> } <del> pidToPortsMapping.get(matchingCandidate.pid)?.push(forwardedPort.port); </del> <ins> pidToPortsMapping.get(pid)?.push(forwardedPort.port); </ins> } });

pid?: number; } <ins> export function isCandidatePort(candidate: any): candidate is CandidatePort { return candidate && 'host' in candidate && typeof candidate.host === 'string' && 'port' in candidate && typeof candidate.port === 'number' && (!('detail' in candidate) || typeof candidate.detail === 'string') && (!('pid' in candidate) || typeof candidate.pid === 'string'); } </ins> export interface IRemoteExplorerService { readonly _serviceBrand: undefined; onDidChangeTargetType: Event<string[]>;

autoForwardAction: PortAutoForwardAction; /** <del> * @deprecated */ constructor(port: number, autoForwardAction: PortAutoForwardAction); /** </del> * Creates a new PortAttributes object * @param port the port number * @param autoForwardAction the action to take when this port is detected