jiebi/CodeConvo huggingface dataset:
Code change:
Open terminal and run command After it finishes, there is a freeze. Some times I see window is not responding dialog Now type command Freezes again Here is the profile that is captured while running command Here is the profile that is captured while running command I have set to
getOutputMatch can be too expensive: ! Is some quick fix not working on just a small line range?
The second one: !
Oh none of the quick fixes use offset or length currently. We should force that, otherwise the regex will run on every line.

Related discussion:
text: return { actionName: (matchResult: ContextualMatchResult) => matchResult.outputMatch ? `Create PR for ${matchResult.outputMatch[1]}` : '', commandLineMatcher: GitPushCommandLineRegex, <del> outputMatcher: { lineMatcher: GitCreatePrOutputRegex, anchor: 'bottom' }, </del> <ins> outputMatcher: { lineMatcher: GitCreatePrOutputRegex, anchor: 'bottom', offset: 0, length: 5 }, </ins> exitStatus: true, getActions: (matchResult: ContextualMatchResult, command?: ITerminalCommand) => { if (!command) {
Code change:
Testing clone a repo from within VS Code when done a notification is shown IMO a modal is the better choice of UI because this something I am awaiting and wanting to take action on <img width="1527" alt="Screenshot 2022-09-27 at 11 15 02" src="https://user-"
it makes sense to me. please let me know if you have any concerns. Thanks!
, as having notifications snoozed always, I was missing this notification but I think it should be modal as it is part of a flow that I triggered.
No concerns with using a modal

Related discussion:
text: choices.push(addToWorkspace); } <del> const result = await window.showInformationMessage(message, ...choices); </del> <ins> const result = await window.showInformationMessage(message, { modal: true }, ...choices); </ins> action = result === open ? PostCloneAction.Open : result === openNewWindow ? PostCloneAction.OpenNewWindow
Code change:
Testing The feature is called . But it does more than fetch, it also pulls. Fetch typically only 'downloads' commits, but does not update any branches. Maybe the proper name would be:

Related discussion:
text: "default": false, "description": "%config.rebaseWhenSync%" }, <del> "git.fetchBeforeCheckout": { </del> <ins> "git.pullBeforeCheckout": { </ins> "type": "boolean", "scope": "resource", "default": false, <del> "description": "%config.fetchBeforeCheckout%" </del> <ins> "description": "%config.pullBeforeCheckout%" </ins> }, "git.fetchOnPull": { "type": "boolean",
Code change:
Testing The feature is called . But it does more than fetch, it also pulls. Fetch typically only 'downloads' commits, but does not update any branches. Maybe the proper name would be:

Related discussion:
text: "config.rebaseWhenSync": "Force git to use rebase when running the sync command.", "config.confirmEmptyCommits": "Always confirm the creation of empty commits for the 'Git: Commit Empty' command.", "config.fetchOnPull": "When enabled, fetch all branches when pulling. Otherwise, fetch just the current one.", <del> "config.fetchBeforeCheckout": "Controls whether a branch that does not have outgoing commits is fast-forwarded before it is checked out.", </del> <ins> "config.pullBeforeCheckout": "Controls whether a branch that does not have outgoing commits is fast-forwarded before it is checked out.", </ins> "config.pullTags": "Fetch all tags when pulling.", "config.pruneOnFetch": "Prune when fetching.", "config.autoStash": "Stash any changes before pulling and restore them after successful pull.",
Code change:
Testing The feature is called . But it does more than fetch, it also pulls. Fetch typically only 'downloads' commits, but does not update any branches. Maybe the proper name would be:

Related discussion:
text: } const config = workspace.getConfiguration('git', Uri.file(this.repository.root)); <del> const fetchBeforeCheckout = config.get<boolean>('fetchBeforeCheckout', false) === true; </del> <ins> const pullBeforeCheckout = config.get<boolean>('pullBeforeCheckout', false) === true; </ins> <del> if (fetchBeforeCheckout) { </del> <ins> if (pullBeforeCheckout) { </ins> await this.repository.fastForwardBranch(this.ref.name!); }
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: import { sha1Hex } from 'vs/base/browser/hash'; import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; import { IActivityService, NumberBadge } from 'vs/workbench/services/activity/common/activity'; <ins> import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; </ins> registerSingleton(IEditSessionsLogService, EditSessionsLogService, InstantiationType.Delayed); registerSingleton(IEditSessionsStorageService, EditSessionsWorkbenchService, InstantiationType.Delayed);
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: @ILifecycleService private readonly lifecycleService: ILifecycleService, @IStorageService private readonly storageService: IStorageService, @IActivityService private readonly activityService: IActivityService, <ins> @IEditorService private readonly editorService: IEditorService, </ins> ) { super();
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: // Run the store action to get back a ref let ref: string | undefined; if (shouldStoreEditSession) { <del> ref = await that.progressService.withProgress({ location: ProgressLocation.Notification, type: 'syncing', title: localize('store your edit session', 'Storing your edit session...') }, async () => that.storeEditSession(false)); </del> <ins> ref = await that.storeEditSession(false); </ins> } let uri = workspaceUri ?? await that.pickContinueEditSessionDestination();
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: } else if (ref !== undefined) { this.notificationService.warn(localize('no edit session content for ref', 'Could not resume edit session contents for ID {0}.', ref)); } <del> this.logService.info(ref !== undefined ? `Aborting resuming edit session as no edit session content is available to be applied from ref ${ref}.` : `Aborting resuming edit session as no edit session content is available to be applied`); </del> <ins> this.logService.info(`Aborting resuming edit session as no edit session content is available to be applied from ref ${ref}.`); </ins> return; } const editSession = data.editSession;
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: const folders: Folder[] = []; let hasEdits = false; <ins> // Save all saveable editors before building edit session contents await this.editorService.saveAll(); </ins> for (const repository of this.scmService.repositories) { // Look through all resource groups and compute which files were added/modified/deleted const trackedUris = this.getChangedResources(repository); // A URI might appear in more than one resource group
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: import { ITextModelService } from 'vs/editor/common/services/resolverService'; import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { IDialogService } from 'vs/platform/dialogs/common/dialogs'; <ins> import { IEditorService, ISaveAllEditorsOptions } from 'vs/workbench/services/editor/common/editorService'; </ins> const folderName = 'test-folder'; const folderUri = URI.file(`/${folderName}`);
Code change:
Testing I wonder if we should run the command to save all files (not untitled files) before triggering the "Continue on" fully? I think ensuring that dirty files are saved but also that the data was synced up before opening the workspace elsewhere would be best?
I am not presented with any options after running the command - perhaps we shouldn't show that in the command palette unless there are some or add an action that helps me get some options? !
Should we say here? !

Related discussion:
text: instantiationService.stub(ITextModelService, new class extends mock<ITextModelService>() { override registerTextModelContentProvider = () => ({ dispose: () => { } }); }); <ins> instantiationService.stub(IEditorService, new class extends mock<IEditorService>() { override saveAll = async (_options: ISaveAllEditorsOptions) => true; }); </ins> editSessionsContribution = instantiationService.createInstance(EditSessionsContribution); });
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: if (!state.conflicting && !state.isInputIncluded(inputNumber)) { result.push( !state.isInputIncluded(inputNumber) <del> ? command(localize('accept', "$(pass) Accept {0}", inputData.title), async () => { </del> <ins> ? command(localize('accept', "Accept {0}", inputData.title), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: ); }); }) <del> : command(localize('remove', "$(error) Remove {0}", inputData.title), async () => { </del> <ins> : command(localize('remove', "Remove {0}", inputData.title), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: if (modifiedBaseRange.canBeCombined && state.isEmpty) { result.push( state.input1 && state.input2 <del> ? command(localize('removeBoth', "$(error) Remove Both"), async () => { </del> <ins> ? command(localize('removeBoth', "Remove Both"), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: ); }); }) <del> : command(localize('acceptBoth', "$(pass) Accept Both"), async () => { </del> <ins> : command(localize('acceptBoth', "Accept Both"), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: const stateToggles: IContentWidgetAction[] = []; if (state.input1) { <del> result.push(command(localize('remove', "$(error) Remove {0}", model.input1.title), async () => { </del> <ins> result.push(command(localize('remove', "Remove {0}", model.input1.title), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: ); } if (state.input2) { <del> result.push(command(localize('remove', "$(error) Remove {0}", model.input2.title), async () => { </del> <ins> result.push(command(localize('remove', "Remove {0}", model.input2.title), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
Testing I think the merge editor CodeLens actions are the only examples I've seen of icons being used—not sure they are obvious/big enough to really be of much value here. Is there any prior art for using them? <img width="269" alt="CleanShot 2022-09-27 at 11 42 19 src="https://user-"<img width="244" alt="CleanShot 2022-09-27 at 11 43 33 src="https://user-"
I can remove them. Personally I like them, as they give a non-textual clue about what is going to happen.
Why don't we start with the minimal text and then we can always choose to add them (or something else) back. Harder to remove things once they are in.

Related discussion:
text: if (state.conflicting) { result.push( <del> command(localize('resetToBase', "$(error) Reset to base"), async () => { </del> <ins> command(localize('resetToBase', "Reset to base"), async () => { </ins> transaction((tx) => { model.setState( modifiedBaseRange,
Code change:
<img width="364" alt="image" src="https://user-"I think this dialog could get some UX love. If we want to keep the very long primary button label, I would use title casing to be consistent with other dialog buttons. But I also think just having "Accept Merge" is fine, given the message in the dialog points out about the conflicts. //cc
Now that I see this dialog: <img width="291" alt="image" src="https://user-"I think we can align both How about: "Accept with Conflicts" using in the dialog "The file contains unhandled conflicts"
PR:

Related discussion:
text: *--------------------------------------------------------------------------------------------*/ import { Codicon } from 'vs/base/common/codicons'; <ins> import { basename } from 'vs/base/common/resources'; </ins> import { URI, UriComponents } from 'vs/base/common/uri'; import { localize } from 'vs/nls'; import { ILocalizedString } from 'vs/platform/action/common/action';
Code change:
<img width="364" alt="image" src="https://user-"I think this dialog could get some UX love. If we want to keep the very long primary button label, I would use title casing to be consistent with other dialog buttons. But I also think just having "Accept Merge" is fine, given the message in the dialog points out about the conflicts. //cc
Now that I see this dialog: <img width="291" alt="image" src="https://user-"I think we can align both How about: "Accept with Conflicts" using in the dialog "The file contains unhandled conflicts"
PR:

Related discussion:
text: if (viewModel.model.unhandledConflictsCount.get() > 0) { const confirmResult = await dialogService.confirm({ type: 'info', <del> message: localize('mergeEditor.acceptMerge.unhandledConflicts', "There are still unhandled conflicts. Are you sure you want to accept the merge?"), primaryButton: localize('mergeEditor.acceptMerge.unhandledConflicts.accept', "Complete merge with unhandled conflicts"), </del> <ins> message: localize('mergeEditor.acceptMerge.unhandledConflicts.message', "Do you want to complete the merge of {0}?", basename(inputModel.resultUri)), detail: localize('mergeEditor.acceptMerge.unhandledConflicts.detail', "The file contains unhandled conflicts."), primaryButton: localize('mergeEditor.acceptMerge.unhandledConflicts.accept', "Complete with Conflicts"), </ins> secondaryButton: localize('mergeEditor.acceptMerge.unhandledConflicts.cancel', "Cancel"), });
Code change:
Just wondering whether the "Extensions" output channel is actually used for anything? I have checked it when troubleshooting extensions many times and don't think I've ever actually seen any output in there
This is being used by debug adapter Feel free to remove it if you are not using.
Oh, wow No clue about that
I guess it was introduced in , previously showed errors from all extensions, now I think those errors go to other general logs, and probably just this one usage got left behind. any idea if there was some discussion about this in the past? Or I will remove it
not aware of anyone using it. I think we can go ahead and remove it. fyi
bit off-topic here but I was looking around for an issue around a "combined" log (showing the channel inline) - is there such a thing and I'm just missing it? that way I wouldn't have to click around into various logs when I'm trying to figure out what's going on with vscode - I realize I could tail the various files and write a script to make that more convenient I was also thinking maybe an extension could fill that need but then I saw
I think there is an issue to open multiple output channels at once. Please search into our issues.
there are only 10 open issues tagged output - altho this issue is about output and got labeled debug instead - I looked at the debug tagged issues too and didn't see it - should I create one?
Here is the similar request -

Related discussion:
text: *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { Promises } from 'vs/base/node/pfs'; </del> import * as cp from 'child_process'; <del> import * as stream from 'stream'; import * as nls from 'vs/nls'; </del> import * as net from 'net'; <del> import * as path from 'vs/base/common/path'; import * as strings from 'vs/base/common/strings'; </del> <ins> import * as stream from 'stream'; </ins> import * as objects from 'vs/base/common/objects'; <ins> import * as path from 'vs/base/common/path'; </ins> import * as platform from 'vs/base/common/platform'; <del> import { ExtensionsChannelId } from 'vs/platform/extensionManagement/common/extensionManagement'; import { IOutputService } from 'vs/workbench/services/output/common/output'; import { IDebugAdapterExecutable, IDebuggerContribution, IPlatformSpecificAdapterContribution, IDebugAdapterServer, IDebugAdapterNamedPipeServer } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import * as strings from 'vs/base/common/strings'; import { Promises } from 'vs/base/node/pfs'; import * as nls from 'vs/nls'; </ins> import { IExtensionDescription } from 'vs/platform/extensions/common/extensions'; <ins> import { IDebugAdapterExecutable, IDebugAdapterNamedPipeServer, IDebugAdapterServer, IDebuggerContribution, IPlatformSpecificAdapterContribution } from 'vs/workbench/contrib/debug/common/debug'; </ins> import { AbstractDebugAdapter } from '../common/abstractDebugAdapter'; /**