@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/workbench/contrib/comments/browser/commentsController.js

@@ -6,10 +6,11 @@ import { createCancelablePromise, Delayer } from '../../../../base/common/async.
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { DisposableStore, dispose } from '../../../../base/common/lifecycle.js';
 import './media/review.css.js';
+import { isDiffEditor, isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
 import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
 import { Range } from '../../../../editor/common/core/range.js';
 import { EditorType } from '../../../../editor/common/editorCommon.js';
-import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
+import { ModelDecorationOptions, TextModel } from '../../../../editor/common/model/textModel.js';
 import { CommentThreadState } from '../../../../editor/common/languages.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
@@ -17,9 +18,9 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
 import { CommentGlyphWidget } from './commentGlyphWidget.js';
 import { ICommentService } from './commentService.js';
-import { ReviewZoneWidget, parseMouseDownInfoFromEvent, isMouseUpEventDragFromMouseDown } from './commentThreadZoneWidget.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { EmbeddedCodeEditorWidget } from '../../../../editor/browser/widget/embeddedCodeEditorWidget.js';
+import { CommentWidgetFocus, ReviewZoneWidget, parseMouseDownInfoFromEvent, isMouseUpEventDragFromMouseDown } from './commentThreadZoneWidget.js';
+import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { EmbeddedCodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/embeddedCodeEditorWidget.js';
 import { IViewsService } from '../../../services/views/common/viewsService.js';
 import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
@@ -32,6 +33,7 @@ import { status } from '../../../../base/browser/ui/aria/aria.js';
 import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { URI } from '../../../../base/common/uri.js';
 const ID = 'editor.contrib.review';
 class CommentingRangeDecoration {
     get id() {
@@ -168,7 +170,7 @@ class CommentingRangeDecorator {
                     }
                     commentingRangeDecorations.push(( new CommentingRangeDecoration(
                         editor,
-                        info.owner,
+                        info.uniqueOwner,
                         info.extensionId,
                         info.label,
                         intersectingSelectionRange,
@@ -179,7 +181,7 @@ class CommentingRangeDecorator {
                     if (!this._lineHasThread(editor, intersectingEmphasisRange)) {
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             intersectingEmphasisRange,
@@ -196,7 +198,7 @@ class CommentingRangeDecorator {
                         const beforeRange = ( new Range(range.startLineNumber, 1, beforeRangeEndLine, 1));
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             beforeRange,
@@ -209,7 +211,7 @@ class CommentingRangeDecorator {
                         const afterRange = ( new Range(afterRangeStartLine, 1, range.endLineNumber, 1));
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             afterRange,
@@ -224,7 +226,7 @@ class CommentingRangeDecorator {
                         const beforeRange = ( new Range(range.startLineNumber, 1, emphasisLine - 1, 1));
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             beforeRange,
@@ -237,7 +239,7 @@ class CommentingRangeDecorator {
                     if (!this._lineHasThread(editor, emphasisRange)) {
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             emphasisRange,
@@ -250,7 +252,7 @@ class CommentingRangeDecorator {
                         const afterRange = ( new Range(emphasisLine + 1, 1, range.endLineNumber, 1));
                         commentingRangeDecorations.push(( new CommentingRangeDecoration(
                             editor,
-                            info.owner,
+                            info.uniqueOwner,
                             info.extensionId,
                             info.label,
                             afterRange,
@@ -263,7 +265,7 @@ class CommentingRangeDecorator {
                 else {
                     commentingRangeDecorations.push(( new CommentingRangeDecoration(
                         editor,
-                        info.owner,
+                        info.uniqueOwner,
                         info.extensionId,
                         info.label,
                         range,
@@ -299,7 +301,7 @@ class CommentingRangeDecorator {
                 return ( foundInfos.map(foundInfo => {
                     return {
                         action: {
-                            ownerId: foundInfo.owner,
+                            ownerId: foundInfo.uniqueOwner,
                             extensionId: foundInfo.extensionId,
                             label: foundInfo.label,
                             commentingRangesInfo: foundInfo.commentingRanges
@@ -384,6 +386,48 @@ class CommentingRangeDecorator {
         this.commentingRangeDecorations = [];
     }
 }
+function revealCommentThread(commentService, editorService, uriIdentityService, commentThread, comment, focusReply, pinned, preserveFocus, sideBySide) {
+    if (!commentThread.resource) {
+        return;
+    }
+    if (!commentService.isCommentingEnabled) {
+        commentService.enableCommenting(true);
+    }
+    const range = commentThread.range;
+    const focus = focusReply ? CommentWidgetFocus.Editor : (preserveFocus ? CommentWidgetFocus.None : CommentWidgetFocus.Widget);
+    const activeEditor = editorService.activeTextEditorControl;
+    const currentActiveResources = isDiffEditor(activeEditor) ? [activeEditor.getOriginalEditor(), activeEditor.getModifiedEditor()]
+        : (activeEditor ? [activeEditor] : []);
+    const threadToReveal = commentThread.threadId;
+    const commentToReveal = comment?.uniqueIdInThread;
+    const resource = ( URI.parse(commentThread.resource));
+    for (const editor of currentActiveResources) {
+        const model = editor.getModel();
+        if ((model instanceof TextModel) && uriIdentityService.extUri.isEqual(resource, model.uri)) {
+            if (threadToReveal && isCodeEditor(editor)) {
+                const controller = CommentController.get(editor);
+                controller?.revealCommentThread(threadToReveal, commentToReveal, true, focus);
+            }
+            return;
+        }
+    }
+    editorService.openEditor({
+        resource,
+        options: {
+            pinned: pinned,
+            preserveFocus: preserveFocus,
+            selection: range ?? ( new Range(1, 1, 1, 1))
+        }
+    }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP).then(editor => {
+        if (editor) {
+            const control = editor.getControl();
+            if (threadToReveal && isCodeEditor(control)) {
+                const controller = CommentController.get(control);
+                controller?.revealCommentThread(threadToReveal, commentToReveal, true, focus);
+            }
+        }
+    });
+}
 let CommentController = class CommentController {
     constructor(editor, commentService, instantiationService, codeEditorService, contextMenuService, quickInputService, viewsService, configurationService, contextKeyService, editorService, keybindingService, accessibilityService) {
         this.commentService = commentService;
@@ -400,6 +444,7 @@ let CommentController = class CommentController {
         this.localToDispose = ( new DisposableStore());
         this.mouseDownInfo = null;
         this._commentingRangeSpaceReserved = false;
+        this._commentingRangeAmountReserved = 0;
         this._emptyThreadsToAddQueue = [];
         this._inProcessContinueOnComments = ( new Map());
         this._editorDisposables = [];
@@ -458,6 +503,7 @@ let CommentController = class CommentController {
                 this._commentWidgets = [];
             }
         }));
+        this.globalToDispose.add(this.editor.onWillChangeModel(e => this.onWillChangeModel(e)));
         this.globalToDispose.add(this.editor.onDidChangeModel(_ => this.onModelChanged()));
         this.globalToDispose.add(this.configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration('diffEditor.renderSideBySide')) {
@@ -488,7 +534,7 @@ let CommentController = class CommentController {
                         }
                         if (pendingNewComment !== lastCommentBody) {
                             pendingComments.push({
-                                owner: zone.owner,
+                                uniqueOwner: zone.uniqueOwner,
                                 uri: zone.editor.getModel().uri,
                                 range: zone.commentThread.range,
                                 body: pendingNewComment,
@@ -696,7 +742,7 @@ let CommentController = class CommentController {
             nextWidget = sortedWidgets[idx];
         }
         this.editor.setSelection(nextWidget.commentThread.range ?? ( new Range(1, 1, 1, 1)));
-        nextWidget.reveal(undefined, true);
+        nextWidget.reveal(undefined, CommentWidgetFocus.Widget);
     }
     previousCommentThread() {
         this._findNearestCommentThread(true);
@@ -745,8 +791,14 @@ let CommentController = class CommentController {
         dispose(this._commentWidgets);
         this.editor = null;
     }
+    onWillChangeModel(e) {
+        if (e.newModelUrl) {
+            this.tryUpdateReservedSpace(e.newModelUrl);
+        }
+    }
     onModelChanged() {
         this.localToDispose.clear();
+        this.tryUpdateReservedSpace();
         this.removeCommentWidgetsAndStoreCache();
         if (!this.editor) {
             return;
@@ -776,7 +828,7 @@ let CommentController = class CommentController {
             if (this._computePromise) {
                 await this._computePromise;
             }
-            const commentInfo = this._commentInfos.filter(info => info.owner === e.owner);
+            const commentInfo = this._commentInfos.filter(info => info.uniqueOwner === e.uniqueOwner);
             if (!commentInfo || !commentInfo.length) {
                 return;
             }
@@ -785,14 +837,14 @@ let CommentController = class CommentController {
             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 !== '');
+                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.uniqueOwner === e.uniqueOwner && zoneWidget.commentThread.threadId === thread.threadId && zoneWidget.commentThread.threadId !== '');
                 if (matchedZones.length) {
                     const matchedZone = matchedZones[0];
                     const index = this._commentWidgets.indexOf(matchedZone);
                     this._commentWidgets.splice(index, 1);
                     matchedZone.dispose();
                 }
-                const infosThreads = this._commentInfos.filter(info => info.owner === e.owner)[0].threads;
+                const infosThreads = this._commentInfos.filter(info => info.uniqueOwner === e.uniqueOwner)[0].threads;
                 for (let i = 0; i < infosThreads.length; i++) {
                     if (infosThreads[i] === thread) {
                         infosThreads.splice(i, 1);
@@ -801,7 +853,7 @@ let CommentController = class CommentController {
                 }
             });
             changed.forEach(thread => {
-                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId);
+                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.uniqueOwner === e.uniqueOwner && zoneWidget.commentThread.threadId === thread.threadId);
                 if (matchedZones.length) {
                     const matchedZone = matchedZones[0];
                     matchedZone.update(thread);
@@ -809,16 +861,16 @@ let CommentController = class CommentController {
                 }
             });
             for (const thread of added) {
-                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId);
+                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.uniqueOwner === e.uniqueOwner && zoneWidget.commentThread.threadId === thread.threadId);
                 if (matchedZones.length) {
                     return;
                 }
-                const matchedNewCommentThreadZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.commentThreadHandle === -1 && Range.equalsRange(zoneWidget.commentThread.range, thread.range));
+                const matchedNewCommentThreadZones = this._commentWidgets.filter(zoneWidget => zoneWidget.uniqueOwner === e.uniqueOwner && zoneWidget.commentThread.commentThreadHandle === -1 && Range.equalsRange(zoneWidget.commentThread.range, thread.range));
                 if (matchedNewCommentThreadZones.length) {
                     matchedNewCommentThreadZones[0].update(thread);
                     return;
                 }
-                const continueOnCommentIndex = this._inProcessContinueOnComments.get(e.owner)?.findIndex(pending => {
+                const continueOnCommentIndex = this._inProcessContinueOnComments.get(e.uniqueOwner)?.findIndex(pending => {
                     if (pending.range === undefined) {
                         return thread.range === undefined;
                     }
@@ -828,13 +880,13 @@ let CommentController = class CommentController {
                 });
                 let continueOnCommentText;
                 if ((continueOnCommentIndex !== undefined) && continueOnCommentIndex >= 0) {
-                    continueOnCommentText = this._inProcessContinueOnComments.get(e.owner)?.splice(continueOnCommentIndex, 1)[0].body;
+                    continueOnCommentText = this._inProcessContinueOnComments.get(e.uniqueOwner)?.splice(continueOnCommentIndex, 1)[0].body;
                 }
-                const pendingCommentText = (this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId])
+                const pendingCommentText = (this._pendingNewCommentCache[e.uniqueOwner] && this._pendingNewCommentCache[e.uniqueOwner][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);
+                const pendingEdits = this._pendingEditsCache[e.uniqueOwner] && this._pendingEditsCache[e.uniqueOwner][thread.threadId];
+                this.displayCommentThread(e.uniqueOwner, thread, pendingCommentText, pendingEdits);
+                this._commentInfos.filter(info => info.uniqueOwner === e.uniqueOwner)[0].threads.push(thread);
                 this.tryUpdateReservedSpace();
             }
             for (const thread of pending) {
@@ -845,13 +897,13 @@ let CommentController = class CommentController {
         this.beginComputeAndHandleEditorChange();
     }
     async resumePendingComment(editorURI, thread) {
-        const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === thread.owner && Range.lift(zoneWidget.commentThread.range)?.equalsRange(thread.range));
+        const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.uniqueOwner === thread.uniqueOwner && Range.lift(zoneWidget.commentThread.range)?.equalsRange(thread.range));
         if (thread.isReply && matchedZones.length) {
-            this.commentService.removeContinueOnComment({ owner: thread.owner, uri: editorURI, range: thread.range, isReply: true });
+            this.commentService.removeContinueOnComment({ uniqueOwner: thread.uniqueOwner, uri: editorURI, range: thread.range, isReply: true });
             matchedZones[0].setPendingComment(thread.body);
         }
         else if (matchedZones.length) {
-            this.commentService.removeContinueOnComment({ owner: thread.owner, uri: editorURI, range: thread.range, isReply: false });
+            this.commentService.removeContinueOnComment({ uniqueOwner: thread.uniqueOwner, uri: editorURI, range: thread.range, isReply: false });
             const existingPendingComment = matchedZones[0].getPendingComments().newComment;
             let pendingComment;
             if (!existingPendingComment || thread.body.includes(existingPendingComment)) {
@@ -866,15 +918,15 @@ let CommentController = class CommentController {
             matchedZones[0].setPendingComment(pendingComment);
         }
         else if (!thread.isReply) {
-            const threadStillAvailable = this.commentService.removeContinueOnComment({ owner: thread.owner, uri: editorURI, range: thread.range, isReply: false });
+            const threadStillAvailable = this.commentService.removeContinueOnComment({ uniqueOwner: thread.uniqueOwner, uri: editorURI, range: thread.range, isReply: false });
             if (!threadStillAvailable) {
                 return;
             }
-            if (!( this._inProcessContinueOnComments.has(thread.owner))) {
-                this._inProcessContinueOnComments.set(thread.owner, []);
+            if (!( this._inProcessContinueOnComments.has(thread.uniqueOwner))) {
+                this._inProcessContinueOnComments.set(thread.uniqueOwner, []);
             }
-            this._inProcessContinueOnComments.get(thread.owner)?.push(thread);
-            await this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, thread.range ? Range.lift(thread.range) : undefined);
+            this._inProcessContinueOnComments.get(thread.uniqueOwner)?.push(thread);
+            await this.commentService.createCommentThreadTemplate(thread.uniqueOwner, thread.uri, thread.range ? Range.lift(thread.range) : undefined);
         }
     }
     beginComputeAndHandleEditorChange() {
@@ -929,7 +981,7 @@ let CommentController = class CommentController {
         }
         return undefined;
     }
-    displayCommentThread(owner, thread, pendingComment, pendingEdits) {
+    displayCommentThread(uniqueOwner, thread, pendingComment, pendingEdits) {
         const editor = this.editor?.getModel();
         if (!editor) {
             return;
@@ -939,9 +991,9 @@ let CommentController = class CommentController {
         }
         let continueOnCommentReply;
         if (thread.range && !pendingComment) {
-            continueOnCommentReply = this.commentService.removeContinueOnComment({ owner, uri: editor.uri, range: thread.range, isReply: true });
+            continueOnCommentReply = this.commentService.removeContinueOnComment({ uniqueOwner, uri: editor.uri, range: thread.range, isReply: true });
         }
-        const zoneWidget = this.instantiationService.createInstance(ReviewZoneWidget, this.editor, owner, thread, pendingComment ?? continueOnCommentReply?.body, pendingEdits);
+        const zoneWidget = this.instantiationService.createInstance(ReviewZoneWidget, this.editor, uniqueOwner, thread, pendingComment ?? continueOnCommentReply?.body, pendingEdits);
         zoneWidget.display(thread.range);
         this._commentWidgets.push(zoneWidget);
         this.openCommentsView(thread);
@@ -1134,15 +1186,19 @@ let CommentController = class CommentController {
         lineDecorationsWidth -= 24;
         return { extraEditorClassName, lineDecorationsWidth };
     }
-    getWithCommentsEditorOptions(editor, extraEditorClassName, startingLineDecorationsWidth) {
+    getWithCommentsLineDecorationWidth(editor, startingLineDecorationsWidth) {
         let lineDecorationsWidth = startingLineDecorationsWidth;
         const options = editor.getOptions();
         if (options.get(43 ) && options.get(110 ) !== 'never') {
             lineDecorationsWidth -= 11;
         }
         lineDecorationsWidth += 24;
+        this._commentingRangeAmountReserved = lineDecorationsWidth;
+        return this._commentingRangeAmountReserved;
+    }
+    getWithCommentsEditorOptions(editor, extraEditorClassName, startingLineDecorationsWidth) {
         extraEditorClassName.push('inline-comment');
-        return { lineDecorationsWidth, extraEditorClassName };
+        return { lineDecorationsWidth: this.getWithCommentsLineDecorationWidth(editor, startingLineDecorationsWidth), extraEditorClassName };
     }
     updateEditorLayoutOptions(editor, extraEditorClassName, lineDecorationsWidth) {
         editor.updateOptions({
@@ -1150,19 +1206,35 @@ let CommentController = class CommentController {
             lineDecorationsWidth: lineDecorationsWidth
         });
     }
-    tryUpdateReservedSpace() {
+    ensureCommentingRangeReservedAmount(editor) {
+        const existing = this.getExistingCommentEditorOptions(editor);
+        if (existing.lineDecorationsWidth !== this._commentingRangeAmountReserved) {
+            editor.updateOptions({
+                lineDecorationsWidth: this.getWithCommentsLineDecorationWidth(editor, existing.lineDecorationsWidth)
+            });
+        }
+    }
+    tryUpdateReservedSpace(uri) {
         if (!this.editor) {
             return;
         }
-        const hasCommentsOrRanges = ( this._commentInfos.some(info => {
+        const hasCommentsOrRangesInInfo = ( this._commentInfos.some(info => {
             const hasRanges = Boolean(info.commentingRanges && (Array.isArray(info.commentingRanges) ? info.commentingRanges : info.commentingRanges.ranges).length);
             return hasRanges || (info.threads.length > 0);
         }));
-        if (hasCommentsOrRanges && !this._commentingRangeSpaceReserved && this.commentService.isCommentingEnabled) {
-            this._commentingRangeSpaceReserved = true;
-            const { lineDecorationsWidth, extraEditorClassName } = this.getExistingCommentEditorOptions(this.editor);
-            const newOptions = this.getWithCommentsEditorOptions(this.editor, extraEditorClassName, lineDecorationsWidth);
-            this.updateEditorLayoutOptions(this.editor, newOptions.extraEditorClassName, newOptions.lineDecorationsWidth);
+        uri = uri ?? this.editor.getModel()?.uri;
+        const resourceHasCommentingRanges = uri ? this.commentService.resourceHasCommentingRanges(uri) : false;
+        const hasCommentsOrRanges = hasCommentsOrRangesInInfo || resourceHasCommentingRanges;
+        if (hasCommentsOrRanges && this.commentService.isCommentingEnabled) {
+            if (!this._commentingRangeSpaceReserved) {
+                this._commentingRangeSpaceReserved = true;
+                const { lineDecorationsWidth, extraEditorClassName } = this.getExistingCommentEditorOptions(this.editor);
+                const newOptions = this.getWithCommentsEditorOptions(this.editor, extraEditorClassName, lineDecorationsWidth);
+                this.updateEditorLayoutOptions(this.editor, newOptions.extraEditorClassName, newOptions.lineDecorationsWidth);
+            }
+            else {
+                this.ensureCommentingRangeReservedAmount(this.editor);
+            }
         }
         else if ((!hasCommentsOrRanges || !this.commentService.isCommentingEnabled) && this._commentingRangeSpaceReserved) {
             this._commentingRangeSpaceReserved = false;
@@ -1183,8 +1255,8 @@ let CommentController = class CommentController {
             if (!hasCommentingRanges && (info.commentingRanges.ranges.length > 0 || info.commentingRanges.fileComments)) {
                 hasCommentingRanges = true;
             }
-            const providerCacheStore = this._pendingNewCommentCache[info.owner];
-            const providerEditsCacheStore = this._pendingEditsCache[info.owner];
+            const providerCacheStore = this._pendingNewCommentCache[info.uniqueOwner];
+            const providerEditsCacheStore = this._pendingEditsCache[info.uniqueOwner];
             info.threads = info.threads.filter(thread => !thread.isDisposed);
             info.threads.forEach(thread => {
                 let pendingComment = undefined;
@@ -1195,7 +1267,7 @@ let CommentController = class CommentController {
                 if (providerEditsCacheStore) {
                     pendingEdits = providerEditsCacheStore[thread.threadId];
                 }
-                this.displayCommentThread(info.owner, thread, pendingComment, pendingEdits);
+                this.displayCommentThread(info.uniqueOwner, thread, pendingComment, pendingEdits);
             });
             for (const thread of info.pendingCommentThreads ?? []) {
                 this.resumePendingComment(this.editor.getModel().uri, thread);
@@ -1222,7 +1294,7 @@ let CommentController = class CommentController {
             this._commentWidgets.forEach(zone => {
                 const pendingComments = zone.getPendingComments();
                 const pendingNewComment = pendingComments.newComment;
-                const providerNewCommentCacheStore = this._pendingNewCommentCache[zone.owner];
+                const providerNewCommentCacheStore = this._pendingNewCommentCache[zone.uniqueOwner];
                 let lastCommentBody;
                 if (zone.commentThread.comments && zone.commentThread.comments.length) {
                     const lastComment = zone.commentThread.comments[zone.commentThread.comments.length - 1];
@@ -1235,9 +1307,9 @@ let CommentController = class CommentController {
                 }
                 if (pendingNewComment && (pendingNewComment !== lastCommentBody)) {
                     if (!providerNewCommentCacheStore) {
-                        this._pendingNewCommentCache[zone.owner] = {};
+                        this._pendingNewCommentCache[zone.uniqueOwner] = {};
                     }
-                    this._pendingNewCommentCache[zone.owner][zone.commentThread.threadId] = pendingNewComment;
+                    this._pendingNewCommentCache[zone.uniqueOwner][zone.commentThread.threadId] = pendingNewComment;
                 }
                 else {
                     if (providerNewCommentCacheStore) {
@@ -1245,12 +1317,12 @@ let CommentController = class CommentController {
                     }
                 }
                 const pendingEdits = pendingComments.edits;
-                const providerEditsCacheStore = this._pendingEditsCache[zone.owner];
+                const providerEditsCacheStore = this._pendingEditsCache[zone.uniqueOwner];
                 if (( Object.keys(pendingEdits)).length > 0) {
                     if (!providerEditsCacheStore) {
-                        this._pendingEditsCache[zone.owner] = {};
+                        this._pendingEditsCache[zone.uniqueOwner] = {};
                     }
-                    this._pendingEditsCache[zone.owner][zone.commentThread.threadId] = pendingEdits;
+                    this._pendingEditsCache[zone.uniqueOwner][zone.commentThread.threadId] = pendingEdits;
                 }
                 else if (providerEditsCacheStore) {
                     delete providerEditsCacheStore[zone.commentThread.threadId];
@@ -1274,4 +1346,4 @@ CommentController = ( __decorate([
     ( __param(10, IKeybindingService)),
     ( __param(11, IAccessibilityService))
 ], CommentController));
-export { CommentController, ID };
+export { CommentController, ID, revealCommentThread };

package/vscode/src/vs/workbench/contrib/comments/browser/commentsModel.js

@@ -22,14 +22,14 @@ class CommentsModel extends Disposable {
             return ( a.resource.toString()) > ( b.resource.toString()) ? 1 : -1;
         });
     }
-    setCommentThreads(owner, ownerLabel, commentThreads) {
-        this.commentThreadsMap.set(owner, { ownerLabel, resourceWithCommentThreads: this.groupByResource(owner, commentThreads) });
+    setCommentThreads(uniqueOwner, owner, ownerLabel, commentThreads) {
+        this.commentThreadsMap.set(uniqueOwner, { ownerLabel, resourceWithCommentThreads: this.groupByResource(uniqueOwner, owner, commentThreads) });
         this.updateResourceCommentThreads();
     }
-    deleteCommentsByOwner(owner) {
-        if (owner) {
-            const existingOwner = this.commentThreadsMap.get(owner);
-            this.commentThreadsMap.set(owner, { ownerLabel: existingOwner?.ownerLabel, resourceWithCommentThreads: [] });
+    deleteCommentsByOwner(uniqueOwner) {
+        if (uniqueOwner) {
+            const existingOwner = this.commentThreadsMap.get(uniqueOwner);
+            this.commentThreadsMap.set(uniqueOwner, { ownerLabel: existingOwner?.ownerLabel, resourceWithCommentThreads: [] });
         }
         else {
             this.commentThreadsMap.clear();
@@ -37,8 +37,8 @@ class CommentsModel extends Disposable {
         this.updateResourceCommentThreads();
     }
     updateCommentThreads(event) {
-        const { owner, ownerLabel, removed, changed, added } = event;
-        const threadsForOwner = this.commentThreadsMap.get(owner)?.resourceWithCommentThreads || [];
+        const { uniqueOwner, owner, ownerLabel, removed, changed, added } = event;
+        const threadsForOwner = this.commentThreadsMap.get(uniqueOwner)?.resourceWithCommentThreads || [];
         removed.forEach(thread => {
             const matchingResourceIndex = threadsForOwner.findIndex((resourceData) => resourceData.id === thread.resource);
             const matchingResourceData = matchingResourceIndex >= 0 ? threadsForOwner[matchingResourceIndex] : undefined;
@@ -58,10 +58,10 @@ class CommentsModel extends Disposable {
             }
             const index = matchingResourceData.commentThreads.findIndex((commentThread) => commentThread.threadId === thread.threadId);
             if (index >= 0) {
-                matchingResourceData.commentThreads[index] = ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread);
+                matchingResourceData.commentThreads[index] = ResourceWithCommentThreads.createCommentNode(uniqueOwner, owner, ( URI.parse(matchingResourceData.id)), thread);
             }
             else if (thread.comments && thread.comments.length) {
-                matchingResourceData.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread));
+                matchingResourceData.commentThreads.push(ResourceWithCommentThreads.createCommentNode(uniqueOwner, owner, ( URI.parse(matchingResourceData.id)), thread));
             }
         });
         added.forEach(thread => {
@@ -69,14 +69,14 @@ class CommentsModel extends Disposable {
             if (existingResource.length) {
                 const resource = existingResource[0];
                 if (thread.comments && thread.comments.length) {
-                    resource.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, resource.resource, thread));
+                    resource.commentThreads.push(ResourceWithCommentThreads.createCommentNode(uniqueOwner, owner, resource.resource, thread));
                 }
             }
             else {
-                threadsForOwner.push(( new ResourceWithCommentThreads(owner, ( URI.parse(thread.resource)), [thread])));
+                threadsForOwner.push(( new ResourceWithCommentThreads(uniqueOwner, owner, ( URI.parse(thread.resource)), [thread])));
             }
         });
-        this.commentThreadsMap.set(owner, { ownerLabel, resourceWithCommentThreads: threadsForOwner });
+        this.commentThreadsMap.set(uniqueOwner, { ownerLabel, resourceWithCommentThreads: threadsForOwner });
         this.updateResourceCommentThreads();
         return removed.length > 0 || changed.length > 0 || added.length > 0;
     }
@@ -95,11 +95,11 @@ class CommentsModel extends Disposable {
             return '';
         }
     }
-    groupByResource(owner, commentThreads) {
+    groupByResource(uniqueOwner, owner, commentThreads) {
         const resourceCommentThreads = [];
         const commentThreadsByResource = ( new Map());
         for (const group of groupBy(commentThreads, CommentsModel._compareURIs)) {
-            commentThreadsByResource.set(group[0].resource, ( new ResourceWithCommentThreads(owner, ( URI.parse(group[0].resource)), group)));
+            commentThreadsByResource.set(group[0].resource, ( new ResourceWithCommentThreads(uniqueOwner, owner, ( URI.parse(group[0].resource)), group)));
         }
         commentThreadsByResource.forEach((v, i, m) => {
             resourceCommentThreads.push(v);