jiebi/CodeConvo huggingface dataset:
Code change:
<!-- Do Not Delete This! featurerequesttemplate --<!-- Please read our Rules of Conduct: --<!-- Please search existing issues to avoid creating duplicates. --<!-- Describe the feature you'd like. --This would replace . Proposal: ts /
Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT License. See in the project root for license information. *
-------------/ declare module 'vscode' { // export enum RelatedInformationType { SymbolInformation = 1, CommandInformation = 2, SearchInformation = 3, SettingInformation = 4 } interface RelatedInformationBaseResult { type: RelatedInformationType; weight: number; } // TODO: Symbols and Search export interface CommandInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.CommandInformation; command: string; } export interface SettingInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.SettingInformation; setting: string; } export type RelatedInformationResult = CommandInformationResult | SettingInformationResult; export interface RelatedInformationProvider { provideRelatedInformation(query: string, token: CancellationToken): ProviderResult<RelatedInformationResult[]; } export interface EmbeddingVectorProvider { provideEmbeddingVector(strings: string[], token: CancellationToken): ProviderResult<number[][]; } export namespace ai { export function getRelatedInformation(query: string, types: RelatedInformationType[], token: CancellationToken): Thenable<RelatedInformationResult[]; export function registerRelatedInformationProvider(type: RelatedInformationType, provider: RelatedInformationProvider): Disposable; export function registerEmbeddingVectorProvider(model: string, provider: EmbeddingVectorProvider): Disposable; } }

Related discussion:
text: }); numOfSmartPicks++; } <del> return { filterMatches }; </del> <ins> return filterMatches; } private async getAiRelatedInformationItems(token?: CancellationToken | undefined) { const settingsRecord = this._keysProvider.getSettingsRecord(); const filterMatches: ISettingMatch[] = []; const relatedInformation = await this.aiRelatedInformationService.getRelatedInformation(this._filter, [RelatedInformationType.SettingInformation], token ?? CancellationToken.None) as SettingInformationResult[]; relatedInformation.sort((a, b) => b.weight - a.weight); for (const info of relatedInformation) { if (info.weight < RemoteSearchProvider.SEMANTIC_SIMILARITY_THRESHOLD || filterMatches.length === RemoteSearchProvider.SEMANTIC_SIMILARITY_MAX_PICKS) { break; } const pick = info.setting; filterMatches.push({ setting: settingsRecord[pick], matches: [settingsRecord[pick].range], matchType: SettingMatchType.RemoteMatch, score: info.weight }); } return filterMatches; </ins> } }
Code change:
<!-- Do Not Delete This! featurerequesttemplate --<!-- Please read our Rules of Conduct: --<!-- Please search existing issues to avoid creating duplicates. --<!-- Describe the feature you'd like. --This would replace . Proposal: ts /
Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT License. See in the project root for license information. *
-------------/ declare module 'vscode' { // export enum RelatedInformationType { SymbolInformation = 1, CommandInformation = 2, SearchInformation = 3, SettingInformation = 4 } interface RelatedInformationBaseResult { type: RelatedInformationType; weight: number; } // TODO: Symbols and Search export interface CommandInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.CommandInformation; command: string; } export interface SettingInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.SettingInformation; setting: string; } export type RelatedInformationResult = CommandInformationResult | SettingInformationResult; export interface RelatedInformationProvider { provideRelatedInformation(query: string, token: CancellationToken): ProviderResult<RelatedInformationResult[]; } export interface EmbeddingVectorProvider { provideEmbeddingVector(strings: string[], token: CancellationToken): ProviderResult<number[][]; } export namespace ai { export function getRelatedInformation(query: string, types: RelatedInformationType[], token: CancellationToken): Thenable<RelatedInformationResult[]; export function registerRelatedInformationProvider(type: RelatedInformationType, provider: RelatedInformationProvider): Disposable; export function registerEmbeddingVectorProvider(model: string, provider: EmbeddingVectorProvider): Disposable; } }

Related discussion:
text: command: string; } <ins> export interface SettingInformationResult extends RelatedInformationResult { type: RelatedInformationType.SettingInformation; setting: string; } </ins> export interface IAiRelatedInformationService { readonly _serviceBrand: undefined;
Code change:
<!-- Do Not Delete This! featurerequesttemplate --<!-- Please read our Rules of Conduct: --<!-- Please search existing issues to avoid creating duplicates. --<!-- Describe the feature you'd like. --This would replace . Proposal: ts /
Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT License. See in the project root for license information. *
-------------/ declare module 'vscode' { // export enum RelatedInformationType { SymbolInformation = 1, CommandInformation = 2, SearchInformation = 3, SettingInformation = 4 } interface RelatedInformationBaseResult { type: RelatedInformationType; weight: number; } // TODO: Symbols and Search export interface CommandInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.CommandInformation; command: string; } export interface SettingInformationResult extends RelatedInformationBaseResult { type: RelatedInformationType.SettingInformation; setting: string; } export type RelatedInformationResult = CommandInformationResult | SettingInformationResult; export interface RelatedInformationProvider { provideRelatedInformation(query: string, token: CancellationToken): ProviderResult<RelatedInformationResult[]; } export interface EmbeddingVectorProvider { provideEmbeddingVector(strings: string[], token: CancellationToken): ProviderResult<number[][]; } export namespace ai { export function getRelatedInformation(query: string, types: RelatedInformationType[], token: CancellationToken): Thenable<RelatedInformationResult[]; export function registerRelatedInformationProvider(type: RelatedInformationType, provider: RelatedInformationProvider): Disposable; export function registerEmbeddingVectorProvider(model: string, provider: EmbeddingVectorProvider): Disposable; } }

Related discussion:
text: import { StopWatch } from 'vs/base/common/stopwatch'; import { ILogService } from 'vs/platform/log/common/log'; <ins> /** * @deprecated Use `IAiRelatedInformationService` instead. */ </ins> export const ISemanticSimilarityService = createDecorator<ISemanticSimilarityService>('ISemanticSimilarityService'); <ins> /** * @deprecated Use `IAiRelatedInformationService` instead. */ </ins> export interface ISemanticSimilarityService { readonly _serviceBrand: undefined;
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: private _readConfiguration() { const options = this._editor.getOption(EditorOption.stickyScroll); if (options.enabled === false) { this._editor.removeOverlayWidget(this._stickyScrollWidget); this._sessionStore.clear();
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: } private _renderStickyScroll() { <del> if (!(this._editor.hasModel())) { </del> <ins> const model = this._editor.getModel(); if (!model || model.isTooLargeForTokenization()) { this._stickyScrollWidget.setState(undefined); </ins> return; } <del> const model = this._editor.getModel(); </del> const stickyLineVersion = this._stickyLineCandidateProvider.getVersionId(); if (stickyLineVersion === undefined || stickyLineVersion === model.getVersionId()) { this._widgetState = this.findScrollWidgetState();
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: return this._lineNumbers; } <del> setState(state: StickyScrollWidgetState): void { dom.clearNode(this._lineNumbersDomNode); dom.clearNode(this._linesDomNode); </del> <ins> setState(state: StickyScrollWidgetState | undefined): void { this._clearStickyWidget(); if (!state) { return; } </ins> this._stickyLines = []; const editorLineHeight = this._editor.getOption(EditorOption.lineHeight); const futureWidgetHeight = state.startLineNumbers.length * editorLineHeight + state.lastLineRelativePosition;
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: this._rootDomNode.style.width = `${layoutInfo.width - layoutInfo.minimap.minimapCanvasOuterWidth - layoutInfo.verticalScrollbarWidth}px`; } <ins> private _clearStickyWidget() { dom.clearNode(this._lineNumbersDomNode); dom.clearNode(this._linesDomNode); this._rootDomNode.style.display = 'none'; } </ins> private _renderRootNode(): void { if (!this._editor._getViewModel()) {
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: const editorLineHeight = this._editor.getOption(EditorOption.lineHeight); const widgetHeight: number = this._lineNumbers.length * editorLineHeight + this._lastLineRelativePosition; <del> this._rootDomNode.style.display = widgetHeight > 0 ? 'block' : 'none'; </del> <ins> if (widgetHeight === 0) { this._clearStickyWidget(); return; } this._rootDomNode.style.display = 'block'; </ins> this._lineNumbersDomNode.style.height = `${widgetHeight}px`; this._linesDomNodeScrollable.style.height = `${widgetHeight}px`; this._rootDomNode.style.height = `${widgetHeight}px`;
Code change:
Repro: a perf profile a ~100mb TypeScript file (duplicate the contents of a large TS file to make this) perf profile ! It doesn't end up working properly anyway: !
After delete and undo: !

Related discussion:
text: 'Variable 0 will be a file name.' ] }, <del> "{0}: tokenization, wrapping and folding have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", </del> <ins> "{0}: tokenization, wrapping, folding and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", </ins> path.basename(model.uri.path) );
Code change:
It should be just "Copy Output", the "to Clipboard" is obvious? This then aligns with other copy actions across the product Testing

Related discussion:
text: "title": "%cleanInvalidImageAttachment.title%" }, { <del> "command": "notebook.cellOutput.copyToClipboard", "title": "%copyOutputToClipboard.title%" </del> <ins> "command": "notebook.cellOutput.copy", "title": "%copyCellOutput.title%" </ins> } ], "notebooks": [
Code change:
It should be just "Copy Output", the "to Clipboard" is obvious? This then aligns with other copy actions across the product Testing

Related discussion:
text: ], "webview/context": [ { <del> "command": "notebook.cellOutput.copyToClipboard", </del> <ins> "command": "notebook.cellOutput.copy", </ins> "when": "webviewId == 'notebook.output' && webviewSection == 'image'" } ]
Code change:
It should be just "Copy Output", the "to Clipboard" is obvious? This then aligns with other copy actions across the product Testing

Related discussion:
text: "newUntitledIpynb.shortTitle": "Jupyter Notebook", "openIpynbInNotebookEditor.title": "Open IPYNB File In Notebook Editor", "cleanInvalidImageAttachment.title": "Clean Invalid Image Attachment Reference", <del> "copyOutputToClipboard.title": "Copy Output to Clipboard", </del> <ins> "copyCellOutput.title": "Copy Output", </ins> "markdownAttachmentRenderer.displayName": { "message": "Markdown-It ipynb Cell Attachment renderer", "comment": [
Code change:
It should be just "Copy Output", the "to Clipboard" is obvious? This then aligns with other copy actions across the product Testing

Related discussion:
text: import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; <del> export const COPY_OUTPUT_COMMAND_ID = 'notebook.cellOutput.copyToClipboard'; </del> <ins> export const COPY_OUTPUT_COMMAND_ID = 'notebook.cellOutput.copy'; </ins> registerAction2(class CopyCellOutputAction extends Action2 { constructor() { super({ id: COPY_OUTPUT_COMMAND_ID, <del> title: localize('notebookActions.copyOutput', "Copy Output to Clipboard"), </del> <ins> title: localize('notebookActions.copyOutput', "Copy Output"), </ins> menu: { id: MenuId.NotebookOutputToolbar, when: NOTEBOOK_CELL_HAS_OUTPUTS
Code change:
Testing open execute a cell that shows issues select copy output no output is copied I'd except that this "just works", at least for its text/markdown output representation

Related discussion:
text: 'application/x.notebook.stream', 'application/vnd.code.notebook.stderr', 'application/x.notebook.stderr', <del> 'text/plain' </del> <ins> 'text/plain', 'text/markdown', 'application/json' </ins> ];
Code change:
Going through the error logs showed the error below . No steps but it is rooted at this line
verification - Perform a few actions in a notebook, add cells, run cells, close/reopen the tab, run more cells Open the dev tools and ensure the error is not in the console

Related discussion:
text: this._loadState(); this._register(this._storageService.onWillSaveState(() => this._saveState())); this._register(this._storageService.onDidChangeValue(StorageScope.WORKSPACE, NotebookKernelHistoryService.STORAGE_KEY, this._register(new DisposableStore()))(() => { <del> this._restoreState(); </del> <ins> this._loadState(); </ins> })); }
Code change:
Going through the error logs showed the error below . No steps but it is rooted at this line
verification - Perform a few actions in a notebook, add cells, run cells, close/reopen the tab, run more cells Open the dev tools and ensure the error is not in the console

Related discussion:
text: } } <del> private _restoreState(): void { const serialized = this._storageService.get(NotebookKernelHistoryService.STORAGE_KEY, StorageScope.WORKSPACE); if (serialized) { try { for (const [viewType, kernels] of JSON.parse(serialized)) { const linkedMap = this._mostRecentKernelsMap[viewType] ?? new LinkedMap<string, string>(); for (const entry of kernels.entries) { linkedMap.set(entry, entry, Touch.AsOld); } this._mostRecentKernelsMap[viewType] = linkedMap; } } catch (e) { console.error('Deserialize notebook kernel history failed', e); } } } </del> private _loadState(): void { const serialized = this._storageService.get(NotebookKernelHistoryService.STORAGE_KEY, StorageScope.WORKSPACE); if (serialized) {
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: import { workspace, window, languages, commands, ExtensionContext, extensions, Uri, ColorInformation, Diagnostic, StatusBarAlignment, TextEditor, TextDocument, FormattingOptions, CancellationToken, FoldingRange, <del> ProviderResult, TextEdit, Range, Position, Disposable, CompletionItem, CompletionList, CompletionContext, Hover, MarkdownString, FoldingContext, DocumentSymbol, SymbolInformation, l10n, TextEditorOptions </del> <ins> ProviderResult, TextEdit, Range, Position, Disposable, CompletionItem, CompletionList, CompletionContext, Hover, MarkdownString, FoldingContext, DocumentSymbol, SymbolInformation, l10n </ins> } from 'vscode'; import { LanguageClientOptions, RequestType, NotificationType, FormattingOptions as LSPFormattingOptions,
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: export namespace SettingIds { export const enableFormatter = 'json.format.enable'; export const enableKeepLines = 'json.format.keepLines'; <del> export const enableSortOnSave = 'json.sortOnSave.enable'; </del> export const enableValidation = 'json.validate.enable'; export const enableSchemaDownload = 'json.schemaDownload.enable'; export const maxItemsComputed = 'json.maxItemsComputed';
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: window.showInformationMessage(l10n.t('JSON schema cache cleared.')); })); <del> toDispose.push(workspace.onWillSaveTextDocument(event => { const sortOnSave = workspace.getConfiguration().get<boolean>(SettingIds.enableSortOnSave); const document = event.document; if (sortOnSave && (document.languageId === 'json' || document.languageId === 'jsonc')) { const documentOptions = getOptionsForDocument(document); const textEditsPromise = getSortTextEdits(document, documentOptions?.tabSize, documentOptions?.insertSpaces); event.waitUntil(textEditsPromise); } })); </del> toDispose.push(commands.registerCommand('json.sort', async () => {
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: function isSchemaResolveError(d: Diagnostic) { return d.code === /* SchemaResolveError */ 0x300; } <del> function getOptionsForDocument(document: TextDocument): TextEditorOptions | undefined { for (const editor of window.visibleTextEditors) { if (editor.document.uri.toString() === document.uri.toString()) { return editor.options; } } return; } </del>
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: "default": false, "description": "%json.format.keepLines.desc%" }, <del> "json.sortOnSave.enable": { "type": "boolean", "scope": "window", "default": false, "description": "%json.sortOnSave.enable.desc%" }, </del> "json.trace.server": { "type": "string", "scope": "window",
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: "json.schemas.schema.desc": "The schema definition for the given URL. The schema only needs to be provided to avoid accesses to the schema URL.", "json.format.enable.desc": "Enable/disable default JSON formatter", "json.format.keepLines.desc" : "Keep all existing new lines when formatting.", <del> "json.sortOnSave.enable.desc": "Enable/disable default sorting on save", </del> "json.validate.enable.desc": "Enable/disable JSON validation.", "json.tracing.desc": "Traces the communication between VS Code and the JSON language server.", "json.colorDecorators.enable.desc": "Enables or disables color decorators",
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: import { Connection, TextDocuments, InitializeParams, InitializeResult, NotificationType, RequestType, <del> DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit, DocumentFormattingRequest, TextDocumentIdentifier, FormattingOptions, Diagnostic </del> <ins> DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit, DocumentFormattingRequest, TextDocumentIdentifier, FormattingOptions, Diagnostic, CodeAction, CodeActionKind </ins> } from 'vscode-languageserver'; import { runSafe, runSafeAsync } from './utils/runner';
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: import { TextDocument, JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration, ClientCapabilities, Range, Position, SortOptions } from 'vscode-json-languageservice'; import { getLanguageModelCache } from './languageModelCache'; import { Utils, URI } from 'vscode-uri'; <ins> import * as l10n from '@vscode/l10n'; </ins> type ISchemaAssociations = Record<string, string[]>;
Code change:
Testing Should be exposed using a code action (specifically a source action) instead of as a setting? Some advantages: We can reuse the existing setting instead of adding a new one Sorting will play nicer with other source actions since users can configure the order in which the actions run Users can trigger source actions through the context menu or with keybindings
Hey that's a good idea! I'll discuss it with the team. What do you think ?
Yes, makes sense!

Related discussion:
text: documentSelector: null, interFileDependencies: false, workspaceDiagnostics: false <del> } </del> <ins> }, codeActionProvider: true </ins> }; return { capabilities };