Adopt StorageScope.WORKSPACE in comments

Part of #183449

src/vs/editor/common/languages.ts

@@ -1644,6 +1644,7 @@ export interface CommentThreadTemplate {
 export interface CommentInfo {
  extensionId?: string;
  threads: CommentThread[];
+ pendingCommentThreads?: PendingCommentThread[];
  commentingRanges: CommentingRanges;
 }
 
@@ -1785,10 +1786,22 @@ export interface Comment {
  readonly timestamp?: string;
 }
 
+export interface PendingCommentThread {
+ body: string;
+ range: IRange;
+ uri: URI;
+ owner: string;
+}
+
 /**
  * @internal
  */
 export interface CommentThreadChangedEvent<T> {
+ /**
+ * Pending comment threads.
+ */
+ readonly pending: PendingCommentThread[];
+
  /**
  * Added comment threads.
  */

src/vs/monaco.d.ts

@@ -7622,6 +7622,13 @@ declare namespace monaco.languages {
  arguments?: any[];
  }
 
+ export interface PendingCommentThread {
+ body: string;
+ range: IRange;
+ uri: Uri;
+ owner: string;
+ }
+
  export interface CodeLens {
  range: IRange;
  id?: string;

src/vs/workbench/api/browser/mainThreadComments.ts

@@ -7,7 +7,6 @@ import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { generateUuid } from 'vs/base/common/uuid';
 import { IRange, Range } from 'vs/editor/common/core/range';
 import * as languages from 'vs/editor/common/languages';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
@@ -287,13 +286,15 @@ export class MainThreadCommentController implements ICommentController {
  this._commentService.updateComments(this._uniqueId, {
  added: [thread],
  removed: [],
- changed: []
+ changed: [],
+ pending: []
  });
  } else {
  this._commentService.updateNotebookComments(this._uniqueId, {
  added: [thread as MainThreadCommentThread<ICellRange>],
  removed: [],
- changed: []
+ changed: [],
+ pending: []
  });
  }
 
@@ -311,13 +312,15 @@ export class MainThreadCommentController implements ICommentController {
  this._commentService.updateComments(this._uniqueId, {
  added: [],
  removed: [],
- changed: [thread]
+ changed: [thread],
+ pending: []
  });
  } else {
  this._commentService.updateNotebookComments(this._uniqueId, {
  added: [],
  removed: [],
- changed: [thread as MainThreadCommentThread<ICellRange>]
+ changed: [thread as MainThreadCommentThread<ICellRange>],
+ pending: []
  });
  }
 
@@ -332,13 +335,15 @@ export class MainThreadCommentController implements ICommentController {
  this._commentService.updateComments(this._uniqueId, {
  added: [],
  removed: [thread],
- changed: []
+ changed: [],
+ pending: []
  });
  } else {
  this._commentService.updateNotebookComments(this._uniqueId, {
  added: [],
  removed: [thread as MainThreadCommentThread<ICellRange>],
- changed: []
+ changed: [],
+ pending: []
  });
  }
  }
@@ -502,8 +507,8 @@ export class MainThreadComments extends Disposable implements MainThreadComments
  }));
  }
 
- $registerCommentController(handle: number, id: string, label: string): void {
- const providerId = generateUuid();
+ $registerCommentController(handle: number, id: string, label: string, extensionId: string): void {
+ const providerId = `${label}-${extensionId}`;
  this._handlers.set(handle, providerId);
 
  const provider = new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {});

src/vs/workbench/api/common/extHost.protocol.ts

@@ -135,7 +135,7 @@ export type CommentThreadChanges<T = IRange> = Partial<{
 }>;
 
 export interface MainThreadCommentsShape extends IDisposable {
- $registerCommentController(handle: number, id: string, label: string): void;
+ $registerCommentController(handle: number, id: string, label: string, extensionId: string): void;
  $unregisterCommentController(handle: number): void;
  $updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void;
  $createCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, range: IRange | ICellRange | undefined, extensionId: ExtensionIdentifier, isTemplate: boolean): languages.CommentThread<IRange | ICellRange> | undefined;

src/vs/workbench/api/common/extHostComments.ts

@@ -592,7 +592,7 @@ export function createExtHostComments(mainContext: IMainContext, commands: ExtHo
  private _id: string,
  private _label: string
  ) {
- proxy.$registerCommentController(this.handle, _id, _label);
+ proxy.$registerCommentController(this.handle, _id, _label, this._extension.identifier.value);
 
  const that = this;
  this.value = Object.freeze({

src/vs/workbench/contrib/comments/browser/commentService.ts

@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as nls from 'vs/nls';
-import { CommentThreadChangedEvent, CommentInfo, Comment, CommentReaction, CommentingRanges, CommentThread, CommentOptions } from 'vs/editor/common/languages';
+import { CommentThreadChangedEvent, CommentInfo, Comment, CommentReaction, CommentingRanges, CommentThread, CommentOptions, PendingCommentThread } from 'vs/editor/common/languages';
 import { createDecorator, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { Event, Emitter } from 'vs/base/common/event';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { Range, IRange } from 'vs/editor/common/core/range';
 import { CancellationToken } from 'vs/base/common/cancellation';
@@ -18,6 +18,7 @@ import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/la
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { COMMENTS_SECTION, ICommentsConfiguration } from 'vs/workbench/contrib/comments/common/commentsConfiguration';
 import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 
 export const ICommentService = createDecorator<ICommentService>('commentService');
 
@@ -69,6 +70,10 @@ export interface ICommentController {
  getNotebookComments(resource: URI, token: CancellationToken): Promise<INotebookCommentInfo>;
 }
 
+export interface IContinueOnCommentProvider {
+ provideContinueOnComments(): PendingCommentThread[];
+}
+
 export interface ICommentService {
  readonly _serviceBrand: undefined;
  readonly onDidSetResourceCommentInfos: Event<IResourceCommentThreadEvent>;
@@ -103,8 +108,12 @@ export interface ICommentService {
  setActiveCommentThread(commentThread: CommentThread<IRange | ICellRange> | null): void;
  setCurrentCommentThread(commentThread: CommentThread<IRange | ICellRange> | undefined): void;
  enableCommenting(enable: boolean): void;
+ registerContinueOnCommentProvider(provider: IContinueOnCommentProvider): IDisposable;
+ removeContinueOnComment(pendingComment: { range: IRange; uri: URI; owner: string }): PendingCommentThread | undefined;
 }
 
+const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
+
 export class CommentService extends Disposable implements ICommentService {
  declare readonly _serviceBrand: undefined;
 
@@ -152,16 +161,49 @@ export class CommentService extends Disposable implements ICommentService {
  private _isCommentingEnabled: boolean = true;
  private _workspaceHasCommenting: IContextKey<boolean>;
 
+ private _continueOnComments = new Map<string, PendingCommentThread[]>(); // owner -> PendingCommentThread[]
+ private _continueOnCommentProviders = new Set<IContinueOnCommentProvider>();
+
  constructor(
  @IInstantiationService protected readonly instantiationService: IInstantiationService,
  @IWorkbenchLayoutService private readonly layoutService: IWorkbenchLayoutService,
  @IConfigurationService private readonly configurationService: IConfigurationService,
- @IContextKeyService contextKeyService: IContextKeyService
+ @IContextKeyService contextKeyService: IContextKeyService,
+ @IStorageService private readonly storageService: IStorageService
  ) {
  super();
  this._handleConfiguration();
  this._handleZenMode();
  this._workspaceHasCommenting = WorkspaceHasCommenting.bindTo(contextKeyService);
+ const storageListener = this._register(new DisposableStore());
+
+ storageListener.add(this.storageService.onDidChangeValue(StorageScope.WORKSPACE, CONTINUE_ON_COMMENTS, storageListener)((v) => {
+ if (!v.external) {
+ return;
+ }
+ const commentsToRestore: PendingCommentThread[] | undefined = this.storageService.getObject(CONTINUE_ON_COMMENTS, StorageScope.WORKSPACE);
+ if (!commentsToRestore) {
+ return;
+ }
+ const changedOwners = this._addContinueOnComments(commentsToRestore);
+ for (const owner of changedOwners) {
+ const evt: ICommentThreadChangedEvent = {
+ owner,
+ pending: this._continueOnComments.get(owner) || [],
+ added: [],
+ removed: [],
+ changed: []
+ };
+ this._onDidUpdateCommentThreads.fire(evt);
+ }
+ }));
+ this._register(storageService.onWillSaveState(() => {
+ for (const provider of this._continueOnCommentProviders) {
+ const pendingComments = provider.provideContinueOnComments();
+ this._addContinueOnComments(pendingComments);
+ }
+ this._saveContinueOnComments();
+ }));
  }
 
  private _handleConfiguration() {
@@ -325,12 +367,17 @@ export class CommentService extends Disposable implements ICommentService {
  async getDocumentComments(resource: URI): Promise<(ICommentInfo | null)[]> {
  const commentControlResult: Promise<ICommentInfo | null>[] = [];
 
- this._commentControls.forEach(control => {
+ for (const control of this._commentControls.values()) {
  commentControlResult.push(control.getDocumentComments(resource, CancellationToken.None)
+ .then(documentComments => {
+ const pendingComments = this._continueOnComments.get(documentComments.owner);
+ documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => pendingComment.uri.toString() === resource.toString());
+ return documentComments;
+ })
  .catch(_ => {
  return null;
  }));
- });
+ }
 
  return Promise.all(commentControlResult);
  }
@@ -347,4 +394,46 @@ export class CommentService extends Disposable implements ICommentService {
 
  return Promise.all(commentControlResult);
  }
+
+ registerContinueOnCommentProvider(provider: IContinueOnCommentProvider): IDisposable {
+ this._continueOnCommentProviders.add(provider);
+ return {
+ dispose: () => {
+ this._continueOnCommentProviders.delete(provider);
+ }
+ };
+ }
+
+ private _saveContinueOnComments() {
+ const commentsToSave: PendingCommentThread[] = [];
+ for (const pendingComments of this._continueOnComments.values()) {
+ commentsToSave.push(...pendingComments);
+ }
+ this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, StorageScope.WORKSPACE, StorageTarget.USER);
+ }
+
+ removeContinueOnComment(pendingComment: { range: IRange; uri: URI; owner: string }): PendingCommentThread | undefined {
+ const pendingComments = this._continueOnComments.get(pendingComment.owner);
+ if (pendingComments) {
+ return pendingComments.splice(pendingComments.findIndex(comment => comment.uri.toString() === pendingComment.uri.toString() && Range.equalsRange(comment.range, pendingComment.range)), 1)[0];
+ }
+ return undefined;
+ }
+
+ private _addContinueOnComments(pendingComments: PendingCommentThread[]): Set<string> {
+ const changedOwners = new Set<string>();
+ for (const pendingComment of pendingComments) {
+ if (!this._continueOnComments.has(pendingComment.owner)) {
+ this._continueOnComments.set(pendingComment.owner, [pendingComment]);
+ changedOwners.add(pendingComment.owner);
+ } else {
+ const commentsForOwner = this._continueOnComments.get(pendingComment.owner)!;
+ if (commentsForOwner.every(comment => (comment.uri.toString() !== pendingComment.uri.toString()) || !Range.equalsRange(comment.range, pendingComment.range) || (comment.body !== pendingComment.body))) {
+ commentsForOwner.push(pendingComment);
+ changedOwners.add(pendingComment.owner);
+ }
+ }
+ }
+ return changedOwners;
+ }
 }

src/vs/workbench/contrib/comments/browser/commentsController.ts

@@ -395,7 +395,39 @@ export class CommentController implements IEditorContribution {
 
  this.onModelChanged();
  this.codeEditorService.registerDecorationType('comment-controller', COMMENTEDITOR_DECORATION_KEY, {});
- this.beginCompute();
+ this.commentService.registerContinueOnCommentProvider({
+ provideContinueOnComments: () => {
+ const pendingComments: languages.PendingCommentThread[] = [];
+ if (this._commentWidgets) {
+ for (const zone of this._commentWidgets) {
+ const zonePendingComments = zone.getPendingComments();
+ const pendingNewComment = zonePendingComments.newComment;
+ if (!pendingNewComment || !zone.commentThread.range) {
+ continue;
+ }
+ let lastCommentBody;
+ if (zone.commentThread.comments && zone.commentThread.comments.length) {
+ const lastComment = zone.commentThread.comments[zone.commentThread.comments.length - 1];
+ if (typeof lastComment.body === 'string') {
+ lastCommentBody = lastComment.body;
+ } else {
+ lastCommentBody = lastComment.body.value;
+ }
+ }
+
+ if (pendingNewComment !== lastCommentBody) {
+ pendingComments.push({
+ owner: zone.owner,
+ uri: zone.editor.getModel()!.uri,
+ range: zone.commentThread.range,
+ body: pendingNewComment
+ });
+ }
+ }
+ }
+ return pendingComments;
+ }
+ });
  }
 
  private registerEditorListeners() {
@@ -671,9 +703,10 @@ export class CommentController implements IEditorContribution {
  return;
  }
 
- const added = e.added.filter(thread => thread.resource && thread.resource.toString() === editorURI.toString());
- const removed = e.removed.filter(thread => thread.resource && thread.resource.toString() === editorURI.toString());
- const changed = e.changed.filter(thread => thread.resource && thread.resource.toString() === editorURI.toString());
+ const added = e.added.filter(thread => thread.resource && thread.resource === editorURI.toString());
+ const removed = e.removed.filter(thread => thread.resource && thread.resource === editorURI.toString());
+ const changed = e.changed.filter(thread => thread.resource && thread.resource === editorURI.toString());
+ const pending = e.pending.filter(pending => pending.uri.toString() === editorURI.toString());
 
  removed.forEach(thread => {
  const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId && zoneWidget.commentThread.threadId !== '');
@@ -713,12 +746,17 @@ export class CommentController implements IEditorContribution {
  return;
  }
 
- const pendingCommentText = this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId!];
+ const continueOnCommentText = (thread.range ? this.commentService.removeContinueOnComment({ owner: e.owner, uri: editorURI, range: thread.range })?.body : undefined);
+ const pendingCommentText = (this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId!])
+ ?? continueOnCommentText;
  const pendingEdits = this._pendingEditsCache[e.owner] && this._pendingEditsCache[e.owner][thread.threadId!];
  this.displayCommentThread(e.owner, thread, pendingCommentText, pendingEdits);
  this._commentInfos.filter(info => info.owner === e.owner)[0].threads.push(thread);
  this.tryUpdateReservedSpace();
  });
+ pending.forEach(thread => {
+ this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
+ });
  this._commentThreadRangeDecorator.update(this.editor, commentInfo);
  }));
 
@@ -1002,6 +1040,9 @@ export class CommentController implements IEditorContribution {
 
  this.displayCommentThread(info.owner, thread, pendingComment, pendingEdits);
  });
+ info.pendingCommentThreads?.forEach(thread => {
+ this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
+ });
  });
 
  this._commentingRangeDecorator.update(this.editor, this._commentInfos);