feat(web): find occurrences when idle

4 files changed, 146 insertions, 8 deletions

diff --git a/language-web/src/main/js/xtext/HighlightingService.ts b/language-web/src/main/js/xtext/HighlightingService.ts
index b8ceed20..451a3a52 100644
--- a/language-web/src/main/js/xtext/HighlightingService.ts
+++ b/language-web/src/main/js/xtext/HighlightingService.ts
@@ -1,7 +1,5 @@
-import { Decoration } from '@codemirror/view';
-import { Range, RangeSet } from '@codemirror/rangeset';
-
 import type { EditorStore } from '../editor/EditorStore';
+import type { IHighlightRange } from '../editor/semanticHighlighting';
 import type { UpdateService } from './UpdateService';
 import { getLogger } from '../utils/logger';
 import { isHighlightingResult } from './xtextServiceResults';
@@ -24,7 +22,7 @@ export class HighlightingService {
       return;
     }
     const allChanges = this.updateService.computeChangesSinceLastUpdate();
-    const decorations: Range<Decoration>[] = [];
+    const ranges: IHighlightRange[] = [];
     push.regions.forEach(({ offset, length, styleClasses }) => {
       if (styleClasses.length === 0) {
         return;
@@ -34,10 +32,12 @@ export class HighlightingService {
       if (to <= from) {
         return;
       }
-      decorations.push(Decoration.mark({
-        class: styleClasses.map((c) => `cmt-problem-${c}`).join(' '),
-      }).range(from, to));
+      ranges.push({
+        from,
+        to,
+        classes: styleClasses,
+      });
     });
-    this.store.updateSemanticHighlighting(RangeSet.of(decorations, true));
+    this.store.updateSemanticHighlighting(ranges);
   }
 }
diff --git a/language-web/src/main/js/xtext/OccurrencesService.ts b/language-web/src/main/js/xtext/OccurrencesService.ts
new file mode 100644
index 00000000..804f5ba2
--- /dev/null
+++ b/language-web/src/main/js/xtext/OccurrencesService.ts
@@ -0,0 +1,116 @@
+import { Transaction } from '@codemirror/state';
+
+import type { EditorStore } from '../editor/EditorStore';
+import type { IOccurrence } from '../editor/findOccurrences';
+import type { UpdateService } from './UpdateService';
+import { getLogger } from '../utils/logger';
+import { Timer } from '../utils/Timer';
+import { XtextWebSocketClient } from './XtextWebSocketClient';
+import {
+  isOccurrencesResult,
+  isServiceConflictResult,
+  ITextRegion,
+} from './xtextServiceResults';
+
+const FIND_OCCURRENCES_TIMEOUT_MS = 1000;
+
+// Must clear occurrences asynchronously from `onTransaction`,
+// because we must not emit a conflicting transaction when handling the pending transaction.
+const CLEAR_OCCURRENCES_TIMEOUT_MS = 10;
+
+const log = getLogger('xtext.OccurrencesService');
+
+function transformOccurrences(regions: ITextRegion[]): IOccurrence[] {
+  const occurrences: IOccurrence[] = [];
+  regions.forEach(({ offset, length }) => {
+    if (length > 0) {
+      occurrences.push({
+        from: offset,
+        to: offset + length,
+      });
+    }
+  });
+  return occurrences;
+}
+
+export class OccurrencesService {
+  private store: EditorStore;
+
+  private webSocketClient: XtextWebSocketClient;
+
+  private updateService: UpdateService;
+
+  private hasOccurrences = false;
+
+  private findOccurrencesTimer = new Timer(() => {
+    this.handleFindOccurrences();
+  }, FIND_OCCURRENCES_TIMEOUT_MS);
+
+  private clearOccurrencesTimer = new Timer(() => {
+    this.clearOccurrences();
+  }, CLEAR_OCCURRENCES_TIMEOUT_MS);
+
+  constructor(
+    store: EditorStore,
+    webSocketClient: XtextWebSocketClient,
+    updateService: UpdateService,
+  ) {
+    this.store = store;
+    this.webSocketClient = webSocketClient;
+    this.updateService = updateService;
+  }
+
+  onTransaction(transaction: Transaction): void {
+    if (transaction.docChanged) {
+      this.clearOccurrencesTimer.schedule();
+      this.findOccurrencesTimer.reschedule();
+    }
+    if (transaction.isUserEvent('select')) {
+      this.findOccurrencesTimer.reschedule();
+    }
+  }
+
+  private handleFindOccurrences() {
+    this.clearOccurrencesTimer.cancel();
+    this.updateOccurrences().catch((error) => {
+      log.error('Unexpected error while updating occurrences', error);
+      this.clearOccurrences();
+    });
+  }
+
+  private async updateOccurrences() {
+    await this.updateService.update();
+    const result = await this.webSocketClient.send({
+      resource: this.updateService.resourceName,
+      serviceType: 'occurrences',
+      expectedStateId: this.updateService.xtextStateId,
+      caretOffset: this.store.state.selection.main.head,
+    });
+    const allChanges = this.updateService.computeChangesSinceLastUpdate();
+    if (!allChanges.empty
+      || (isServiceConflictResult(result) && result.conflict === 'canceled')) {
+      // Stale occurrences result, the user already made some changes.
+      // We can safely ignore the occurrences and schedule a new find occurrences call.
+      this.clearOccurrences();
+      this.findOccurrencesTimer.schedule();
+      return;
+    }
+    if (!isOccurrencesResult(result) || result.stateId !== this.updateService.xtextStateId) {
+      log.error('Unexpected occurrences result', result);
+      this.clearOccurrences();
+      return;
+    }
+    const write = transformOccurrences(result.writeRegions);
+    const read = transformOccurrences(result.readRegions);
+    this.hasOccurrences = write.length > 0 || read.length > 0;
+    log.debug('Found', write.length, 'write and', read.length, 'read occurrences');
+    this.store.updateOccurrences(write, read);
+  }
+
+  private clearOccurrences() {
+    if (this.hasOccurrences) {
+      this.store.updateOccurrences([], []);
+      this.hasOccurrences = false;
+    }
+  }
+}
diff --git a/language-web/src/main/js/xtext/XtextClient.ts b/language-web/src/main/js/xtext/XtextClient.ts
index ccb58ab4..03b81b1c 100644
--- a/language-web/src/main/js/xtext/XtextClient.ts
+++ b/language-web/src/main/js/xtext/XtextClient.ts
@@ -7,6 +7,7 @@ import type { Transaction } from '@codemirror/state';
 import type { EditorStore } from '../editor/EditorStore';
 import { ContentAssistService } from './ContentAssistService';
 import { HighlightingService } from './HighlightingService';
+import { OccurrencesService } from './OccurrencesService';
 import { UpdateService } from './UpdateService';
 import { getLogger } from '../utils/logger';
 import { ValidationService } from './ValidationService';
@@ -25,6 +26,8 @@ export class XtextClient {
 
   private validationService: ValidationService;
 
+  private occurrencesService: OccurrencesService;
+
   constructor(store: EditorStore) {
     this.webSocketClient = new XtextWebSocketClient(
       () => this.updateService.onConnect(),
@@ -34,6 +37,11 @@ export class XtextClient {
     this.contentAssistService = new ContentAssistService(this.updateService);
     this.highlightingService = new HighlightingService(store, this.updateService);
     this.validationService = new ValidationService(store, this.updateService);
+    this.occurrencesService = new OccurrencesService(
+      store,
+      this.webSocketClient,
+      this.updateService,
+    );
   }
 
   onTransaction(transaction: Transaction): void {
@@ -41,6 +49,7 @@ export class XtextClient {
     // _before_ the current edit, so we call it before `updateService`.
     this.contentAssistService.onTransaction(transaction);
     this.updateService.onTransaction(transaction);
+    this.occurrencesService.onTransaction(transaction);
   }
 
   private async onPush(resource: string, stateId: string, service: string, push: unknown) {
diff --git a/language-web/src/main/js/xtext/xtextServiceResults.ts b/language-web/src/main/js/xtext/xtextServiceResults.ts
index e32d49c3..b2de1e4a 100644
--- a/language-web/src/main/js/xtext/xtextServiceResults.ts
+++ b/language-web/src/main/js/xtext/xtextServiceResults.ts
@@ -224,3 +224,16 @@ export function isHighlightingResult(result: unknown): result is IHighlightingRe
   return typeof highlightingResult === 'object'
     && isArrayOfType(highlightingResult.regions, isHighlightingRegion);
 }
+
+export interface IOccurrencesResult extends IDocumentStateResult {
+  writeRegions: ITextRegion[];
+
+  readRegions: ITextRegion[];
+}
+
+export function isOccurrencesResult(result: unknown): result is IOccurrencesResult {
+  const occurrencesResult = result as IOccurrencesResult;
+  return isDocumentStateResult(occurrencesResult)
+    && isArrayOfType(occurrencesResult.writeRegions, isTextRegion)
+    && isArrayOfType(occurrencesResult.readRegions, isTextRegion);
+}