@adecore/editor-react 0.41.1 → 0.43.0

package/src/PickPopup.tsx

@@ -10,7 +10,34 @@ import type { PickPreview, PickView } from './popups.ts';
 const CARD =
     'fixed top-0 left-0 z-(--z-popup) flex w-[420px] flex-col overflow-hidden rounded-lg border border-border bg-surface-raised text-text shadow-(--float-shadow)';
 
+/* The label with the part a query matched marked, whatever the case. */
+function MatchedLabel({ label, query }: { label: string; query: string | null }) {
+    const start = query === null || query === '' ? -1 : label.toLowerCase().indexOf(query.toLowerCase());
+
+    if (query === null || start < 0) {
+        return label;
+    }
+
+    return (
+        <>
+            {label.slice(0, start)}
+            <mark className="bg-transparent font-semibold text-accent">{label.slice(start, start + query.length)}</mark>
+            {label.slice(start + query.length)}
+        </>
+    );
+}
+
 function PreviewLines({ preview }: { preview: PickPreview }) {
+    if (preview.kind === 'text') {
+        return (
+            <div className="max-h-48 overflow-auto border-t border-border p-2 font-mono text-code whitespace-pre">
+                {preview.added.map((line, index) => (
+                    <div key={index}>{line === '' ? ' ' : line}</div>
+                ))}
+            </div>
+        );
+    }
+
     return (
         <div className="flex flex-col gap-px border-t border-border p-1 font-mono text-code">
             {preview.removed.map((line, index) => (
@@ -89,7 +116,12 @@ export function PickPopup({ language, view, rect }: { language: EditorLanguage;
             onPointerDown={(event) => event.preventDefault()}
             {...keepFocusOutOfList(() => language.editor.focus())}
         >
-            {view.title !== null && <div className="border-b border-border px-3 py-1.5 text-xs text-text-muted">{view.title}</div>}
+            {(view.title !== null || view.query !== null) && (
+                <div className="flex items-baseline gap-2 border-b border-border px-3 py-1.5 text-xs text-text-muted">
+                    <span className="min-w-0 truncate">{view.title}</span>
+                    {view.query !== null && view.query !== '' && <span className="ml-auto shrink-0 font-mono text-text">{view.query}</span>}
+                </div>
+            )}
             <div id={listId} role="listbox" className="min-h-0 flex-1 overflow-y-auto p-1">
                 {view.groups.map((group, groupIndex) => (
                     <div key={group.title ?? groupIndex} role="group" className="flex flex-col">
@@ -102,12 +134,15 @@ export function PickPopup({ language, view, rect }: { language: EditorLanguage;
                                 type="button"
                                 role="option"
                                 tabIndex={-1}
-                                aria-selected={row.id === view.active}
+                                aria-selected={row.id === view.active || view.chosen.includes(row.id)}
                                 data-active={row.id === view.active}
-                                className="flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs cursor-row"
-                                onClick={() => language.pick.choose(row.id)}
+                                data-chosen={view.chosen.includes(row.id)}
+                                className="flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs cursor-row data-[chosen=true]:bg-accent/15"
+                                onClick={(event) => language.pick.choose(row.id, { toggle: event.metaKey || event.ctrlKey, range: event.shiftKey })}
                             >
-                                <span className={row.path ? 'shrink-0' : 'min-w-0 truncate'}>{row.label}</span>
+                                <span className={row.path ? 'shrink-0' : 'min-w-0 truncate'}>
+                                    <MatchedLabel label={row.label} query={view.query} />
+                                </span>
                                 {row.path ? (
                                     <PathText path={row.detail} className="ml-auto font-mono text-text-faint" />
                                 ) : (

package/src/WrapCard.tsx

@@ -0,0 +1,64 @@
+import { useLayoutEffect, useRef, useState, type KeyboardEvent } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { EditorRect } from '@adecore/editor';
+import { Input } from '@adecore/ui';
+import { AnchoredPopup } from './AnchoredPopup.tsx';
+import type { EditorLanguage } from './editor-language.ts';
+import type { WrapView } from './popups.ts';
+
+/* The field for the abbreviation a selection is wrapped in: Enter wraps, Escape or leaving the field cancels. */
+export function WrapCard({ language, view, rect }: { language: EditorLanguage; view: WrapView; rect: EditorRect }) {
+    const { t } = useTranslation('editor');
+    const input = useRef<HTMLInputElement>(null);
+    const [value, setValue] = useState('');
+
+    useLayoutEffect(() => {
+        input.current?.focus();
+    }, []);
+
+    function onKeyDown(event: KeyboardEvent<HTMLInputElement>): void {
+        if (event.nativeEvent.isComposing) {
+            return;
+        }
+        if (event.key === 'Escape') {
+            event.preventDefault();
+            event.stopPropagation();
+            language.markup.cancelWrap();
+            language.editor.focus();
+        } else if (event.key === 'Enter') {
+            event.preventDefault();
+            event.stopPropagation();
+            if (value.trim() !== '') {
+                language.markup.submitWrap(value);
+            }
+        }
+    }
+
+    return (
+        <AnchoredPopup rect={rect} placement={{ prefer: 'above' }}>
+            <div className="flex w-[280px] flex-col gap-1.5 p-2">
+                <Input
+                    ref={input}
+                    size="sm"
+                    mono
+                    value={value}
+                    spellCheck={false}
+                    autoComplete="off"
+                    aria-label={t('language.markup.wrap')}
+                    aria-invalid={view.error !== null}
+                    placeholder={t('language.markup.placeholder')}
+                    onChange={(event) => setValue(event.target.value)}
+                    onKeyDown={onKeyDown}
+                    onBlur={() => language.markup.cancelWrap()}
+                />
+                {view.error !== null ? (
+                    <div role="alert" className="text-xs text-status-error">
+                        {view.error}
+                    </div>
+                ) : (
+                    <div className="text-xs text-text-muted">↵ {t('language.markup.apply')}</div>
+                )}
+            </div>
+        </AnchoredPopup>
+    );
+}

package/src/call-hierarchy-model.ts

@@ -1,7 +1,12 @@
-import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Range } from '@adecore/lsp';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Range, TypeHierarchyItem } from '@adecore/lsp';
 
-/* Callers of a symbol, or the symbols it calls. */
-export type CallDirection = 'incoming' | 'outgoing';
+/* Callers of a symbol or the symbols it calls; or the super and sub types of a type, which the same tree draws. */
+export type CallDirection = 'incoming' | 'outgoing' | 'supertypes' | 'subtypes';
+
+/* Whether a direction walks a type hierarchy and not the calls. */
+export function isTypeDirection(direction: CallDirection): direction is 'supertypes' | 'subtypes' {
+    return direction === 'supertypes' || direction === 'subtypes';
+}
 
 /* The most calls of one level that are drawn at once; the rest wait behind a row that shows more. */
 export const CALL_LEVEL_LIMIT = 50;
@@ -103,6 +108,23 @@ export function childrenOf(direction: CallDirection, parent: CallNode, calls: re
     }));
 }
 
+/* The children of a node made from the types a server returned; a type has no call sites, so a row goes to the type itself. */
+export function typeChildrenOf(parent: CallNode, items: readonly TypeHierarchyItem[]): CallNode[] {
+    return items.map((item, index) => ({
+        id: `${parent.id}.${index}`,
+        parent: parent.id,
+        level: parent.level + 1,
+        item,
+        sites: [],
+        siteUri: null,
+        expanded: false,
+        load: 'idle',
+        error: null,
+        children: [],
+        shown: 0
+    }));
+}
+
 /* The lines the tree draws: every root, and under an expanded node its status, its calls and the row that shows more. */
 export function rowsOf(nodes: ReadonlyMap<string, CallNode>, roots: readonly string[]): CallRow[] {
     const rows: CallRow[] = [];

package/src/call-hierarchy.ts

@@ -5,12 +5,14 @@ import type { EditorLanguage } from './editor-language.ts';
 import {
     CALL_LEVEL_LIMIT,
     childrenOf,
+    isTypeDirection,
     moreIdOf,
     rootsOf,
     rowsOf,
     statusIdOf,
     stepsOf,
     targetOf,
+    typeChildrenOf,
     type CallDirection,
     type CallNode,
     type CallRow
@@ -23,6 +25,7 @@ import { realTimers, revealRow, type Timers } from './timers.ts';
 
 const TOAST_ID = 'language-call-hierarchy';
 const PREPARE = 'textDocument/prepareCallHierarchy';
+const PREPARE_TYPES = 'textDocument/prepareTypeHierarchy';
 
 /* The row the panel stands in is as tall as a peek's, plus the segmented control that is a pixel taller than the peek's title bar. */
 export const CALL_HIERARCHY_HEIGHT = PEEK_HEIGHT + 2;
@@ -42,6 +45,7 @@ export class CallHierarchyFeature {
     private nodes = new Map<string, CallNode>();
     private roots: string[] = [];
     private prepared: CallHierarchyItem[] = [];
+    private position: EditorPosition | null = null;
     private direction: CallDirection = 'incoming';
     private controller = new AbortController();
 
@@ -58,11 +62,13 @@ export class CallHierarchyFeature {
 
         const offs = [
             language.onKey((event) => {
-                if (isShortcut(this.language.shortcuts.callHierarchy, event)) {
-                    if (this.isOpen) {
-                        this.setDirection(this.direction === 'incoming' ? 'outgoing' : 'incoming');
+                const calls = isShortcut(this.language.shortcuts.callHierarchy, event);
+                if (calls || isShortcut(this.language.shortcuts.typeHierarchy, event)) {
+                    const [first, second]: CallDirection[] = calls ? ['incoming', 'outgoing'] : ['supertypes', 'subtypes'];
+                    if (this.isOpen && isTypeDirection(this.direction) !== calls) {
+                        this.setDirection(this.direction === first ? second : first);
                     } else {
-                        void this.open();
+                        void this.open(undefined, first);
                     }
 
                     return true;
@@ -88,8 +94,7 @@ export class CallHierarchyFeature {
 
     /* Whether a server of this document answers the three requests the tree is made of. */
     get supported(): boolean {
-        const { project, uri } = this.language;
-        const { service } = project;
+        const { service, uri } = this.language;
 
         return (
             service.prepareCallHierarchy !== undefined &&
@@ -99,12 +104,28 @@ export class CallHierarchyFeature {
         );
     }
 
-    /* Opens the tree for the symbol at the position, on its callers unless told otherwise. */
+    /* Whether a server of this document answers the three requests of the type hierarchy. */
+    get typesSupported(): boolean {
+        const { service, uri } = this.language;
+
+        return (
+            service.prepareTypeHierarchy !== undefined &&
+            service.supertypes !== undefined &&
+            service.subtypes !== undefined &&
+            service.supports(PREPARE_TYPES, uri)
+        );
+    }
+
+    /*
+     * Opens the tree for the symbol at the position, on its callers unless told otherwise; `supertypes` or `subtypes`
+     * open the type hierarchy of the type at the position.
+     */
     async open(position: EditorPosition = this.language.editor.getCaret(), direction: CallDirection = 'incoming'): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, service, uri } = this.language;
+        const types = isTypeDirection(direction);
 
-        if (!this.supported) {
-            this.tell(this.say('unavailable'));
+        if (!(types ? this.typesSupported : this.supported)) {
+            this.tell(this.say(types ? 'typesUnavailable' : 'unavailable'));
 
             return;
         }
@@ -114,10 +135,12 @@ export class CallHierarchyFeature {
         let items: CallHierarchyItem[] | null;
 
         try {
-            items = await project.service.prepareCallHierarchy!(uri, position, { signal: this.controller.signal });
+            const options = { signal: this.controller.signal };
+
+            items = types ? await service.prepareTypeHierarchy!(uri, position, options) : await service.prepareCallHierarchy!(uri, position, options);
         } catch (error) {
             if (epoch === this.epoch && !(error instanceof StaleResultError)) {
-                this.tell(this.say('failed', { message: messageOf(error) }));
+                this.tell(this.say(types ? 'typesFailed' : 'failed', { message: messageOf(error) }));
             }
 
             return;
@@ -128,13 +151,14 @@ export class CallHierarchyFeature {
         }
 
         if (items === null || items.length === 0) {
-            this.tell(this.say('none'));
+            this.tell(this.say(types ? 'typesNone' : 'none'));
 
             return;
         }
 
         this.language.peek.close();
         this.prepared = items;
+        this.position = position;
         this.direction = direction;
         this.seed();
         const active = this.roots[0]!;
@@ -171,7 +195,7 @@ export class CallHierarchyFeature {
         this.language.editor.focus();
     }
 
-    /* Starts the tree over from the same symbols for the other direction. */
+    /* Starts the tree over from the same symbols for the other direction; a switch between calls and types prepares the symbol again. */
     setDirection(direction: CallDirection): void {
         const view = this.language.popups.getState().callHierarchy;
 
@@ -179,6 +203,12 @@ export class CallHierarchyFeature {
             return;
         }
 
+        if (isTypeDirection(direction) !== isTypeDirection(view.direction)) {
+            void this.open(this.position ?? undefined, direction);
+
+            return;
+        }
+
         this.reset();
         this.direction = direction;
         this.seed();
@@ -331,22 +361,19 @@ export class CallHierarchyFeature {
             return;
         }
 
-        const { service, i18n } = this.language.project;
-        const { uri, editor } = this.language;
+        const { i18n } = this.language.project;
+        const { editor } = this.language;
         const { direction, epoch } = this;
         const options = { signal: this.controller.signal, parallel: true };
         this.patch(id, { load: 'loading', error: null });
 
         try {
-            const calls =
-                direction === 'incoming' ? await service.incomingCalls!(uri, node.item, options) : await service.outgoingCalls!(uri, node.item, options);
+            const children = await this.childrenOf(direction, node, options);
 
             if (epoch !== this.epoch) {
                 return;
             }
 
-            const children = childrenOf(direction, node, calls ?? []);
-
             for (const child of children) {
                 this.nodes.set(child.id, child);
             }
@@ -368,6 +395,21 @@ export class CallHierarchyFeature {
         }
     }
 
+    private async childrenOf(direction: CallDirection, node: CallNode, options: { signal: AbortSignal; parallel: boolean }): Promise<CallNode[]> {
+        const { service, uri } = this.language;
+
+        switch (direction) {
+            case 'incoming':
+                return childrenOf(direction, node, (await service.incomingCalls!(uri, node.item, options)) ?? []);
+            case 'outgoing':
+                return childrenOf(direction, node, (await service.outgoingCalls!(uri, node.item, options)) ?? []);
+            case 'supertypes':
+                return typeChildrenOf(node, (await service.supertypes!(uri, node.item, options)) ?? []);
+            case 'subtypes':
+                return typeChildrenOf(node, (await service.subtypes!(uri, node.item, options)) ?? []);
+        }
+    }
+
     private async preview(node: CallNode, site: number): Promise<void> {
         const { project } = this.language;
         const epoch = ++this.previewEpoch;

package/src/clipboard-history.ts

@@ -0,0 +1,102 @@
+/* One copy or cut, as the editors of a project made it. */
+export interface ClipboardEntry {
+    readonly text: string;
+    /* The copy took the lines of bare carets, which paste back above the lines of bare carets. */
+    readonly wholeLines: boolean;
+    readonly at: number;
+}
+
+export interface ClipboardHistoryOptions {
+    /* How many entries the history keeps; 100. */
+    readonly limit?: number;
+    /* The UTF-16 length all entries may take together; 10,000,000. The oldest go first, and the newest stays even when it alone is longer. */
+    readonly maxLength?: number;
+    /* What a host kept, newest first. */
+    readonly entries?: readonly ClipboardEntry[];
+    /* Told after every change, for a host that keeps the entries. */
+    onChange?(entries: readonly ClipboardEntry[]): void;
+    readonly clock?: () => number;
+}
+
+/* The texts copied or cut in the editors of a project, newest first, for Paste from History. */
+export class ClipboardHistory {
+    private readonly limit: number;
+    private readonly maxLength: number;
+    private readonly onChange: ((entries: readonly ClipboardEntry[]) => void) | undefined;
+    private readonly clock: () => number;
+    private readonly listeners = new Set<() => void>();
+    private list: readonly ClipboardEntry[];
+
+    constructor(options: ClipboardHistoryOptions = {}) {
+        this.limit = options.limit ?? 100;
+        this.maxLength = options.maxLength ?? 10_000_000;
+        this.onChange = options.onChange;
+        this.clock = options.clock ?? Date.now;
+        this.list = this.trimmed(options.entries ?? []);
+    }
+
+    /* Newest first. */
+    get entries(): readonly ClipboardEntry[] {
+        return this.list;
+    }
+
+    /* Puts a copy on top. The same text again moves up instead of being kept twice, and nothing is kept for an empty text. */
+    add(text: string, options: { readonly wholeLines?: boolean } = {}): void {
+        if (text === '') {
+            return;
+        }
+
+        const entry = { text, wholeLines: options.wholeLines === true, at: this.clock() };
+
+        this.change([entry, ...this.list.filter((other) => other.text !== text)]);
+    }
+
+    remove(entry: ClipboardEntry): void {
+        if (this.list.includes(entry)) {
+            this.change(this.list.filter((other) => other !== entry));
+        }
+    }
+
+    /* Moves an entry to the top, as choosing it does. */
+    promote(entry: ClipboardEntry): void {
+        if (this.list.includes(entry) && this.list[0] !== entry) {
+            this.change([entry, ...this.list.filter((other) => other !== entry)]);
+        }
+    }
+
+    clear(): void {
+        if (this.list.length > 0) {
+            this.change([]);
+        }
+    }
+
+    subscribe(listener: () => void): () => void {
+        this.listeners.add(listener);
+
+        return () => this.listeners.delete(listener);
+    }
+
+    private change(entries: readonly ClipboardEntry[]): void {
+        this.list = this.trimmed(entries);
+        this.onChange?.(this.list);
+        this.listeners.forEach((listener) => listener());
+    }
+
+    /* Keeps the newest entries that fit the limit and the total length. */
+    private trimmed(entries: readonly ClipboardEntry[]): readonly ClipboardEntry[] {
+        const kept: ClipboardEntry[] = [];
+        let length = 0;
+
+        for (const entry of entries.slice(0, this.limit)) {
+            length += entry.text.length;
+
+            if (kept.length > 0 && length > this.maxLength) {
+                break;
+            }
+
+            kept.push(entry);
+        }
+
+        return kept;
+    }
+}

package/src/code-actions.ts

@@ -13,7 +13,7 @@ import {
     type ActionEntry,
     type ActionGroup
 } from './code-actions-model.ts';
-import type { Problem } from './diagnostics-model.ts';
+import { comparePositions, type Problem } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import type { PickGroup, PickPreview } from './popups.ts';
 import { Refresher } from './refresher.ts';
@@ -122,7 +122,7 @@ export class CodeActionsFeature {
     }
 
     get supported(): boolean {
-        return this.language.project.service.supports(METHOD, this.language.uri);
+        return this.language.service.supports(METHOD, this.language.uri);
     }
 
     /* The list under the caret, or under the selection's start. */
@@ -162,16 +162,16 @@ export class CodeActionsFeature {
     }
 
     async formatDocument(): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
-        if (!project.service.supports('textDocument/formatting', uri)) {
+        if (!this.language.service.supports('textDocument/formatting', uri)) {
             this.tell('error', this.say('noFormatter'));
 
             return;
         }
 
         try {
-            const edits = await project.service.formatting(uri, { ...editor.getIndentation() });
+            const edits = await this.language.service.formatting(uri, { ...editor.getIndentation() });
 
             if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
                 this.tell('error', this.say('readOnly'));
@@ -181,6 +181,43 @@ export class CodeActionsFeature {
         }
     }
 
+    /* Whether a server formats a part of this document, so `formatSelection` has something to ask. */
+    get formatsSelection(): boolean {
+        return this.language.service.supports('textDocument/rangeFormatting', this.language.uri);
+    }
+
+    /*
+     * Formats what is selected, every selection in one request when the server formats several ranges at once and
+     * one by one otherwise; the whole document when nothing is selected.
+     */
+    async formatSelection(): Promise<void> {
+        const { editor, uri } = this.language;
+        const ranges = editor.getSelections().filter((range) => comparePositions(range.start, range.end) !== 0);
+        if (ranges.length === 0) {
+            await this.formatDocument();
+            return;
+        }
+        if (!this.formatsSelection) {
+            this.tell('error', this.say('noFormatter'));
+            return;
+        }
+        const { service } = this.language;
+        const formatting = { ...editor.getIndentation() };
+        try {
+            const edits =
+                service.rangesFormatting !== undefined && service.supports('textDocument/rangesFormatting', uri)
+                    ? await service.rangesFormatting(uri, ranges, formatting)
+                    : (await Promise.all(ranges.map((range) => service.rangeFormatting(uri, range, formatting, { parallel: true })))).flatMap(
+                          (list) => list ?? []
+                      );
+            if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
+                this.tell('error', this.say('readOnly'));
+            }
+        } catch (error) {
+            this.fail(error);
+        }
+    }
+
     /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
     list(only: readonly string[]): Promise<ActionEntry[] | null> {
         if (!this.supported) {
@@ -247,7 +284,7 @@ export class CodeActionsFeature {
 
     /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
     private async request(range: EditorRange, triggerKind: number, options: RequestOptions = {}): Promise<ActionEntry[] | null> {
-        const { project, uri, diagnostics } = this.language;
+        const { uri, diagnostics } = this.language;
         const { only, signal, order } = options;
 
         try {
@@ -264,7 +301,7 @@ export class CodeActionsFeature {
                 triggerKind: triggerKind as 1 | 2
             };
 
-            const entries = actionsOf(await project.service.codeActions(uri, range, context, { signal }), order);
+            const entries = actionsOf(await this.language.service.codeActions(uri, range, context, { signal }), order);
 
             // A server may answer with more than the kinds asked for.
             return only ? entries.filter((entry) => only.some((kind) => entry.action.kind === kind || entry.action.kind?.startsWith(`${kind}.`))) : entries;
@@ -329,13 +366,13 @@ export class CodeActionsFeature {
             return known;
         }
 
-        const { project, uri } = this.language;
+        const { uri } = this.language;
         const { action } = entry;
         let result = action;
 
-        if (action.edit === undefined && project.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
+        if (action.edit === undefined && this.language.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
             try {
-                result = await project.service.resolveCodeAction(uri, action, { signal });
+                result = await this.language.service.resolveCodeAction(uri, action, { signal });
             } catch (error) {
                 if (isRefusal(error)) {
                     throw new ActionRefused((error as Error).message);
@@ -427,7 +464,7 @@ export class CodeActionsFeature {
             if (action.command?.command === INLINE_RENAME_COMMAND) {
                 await this.startRename(action.command);
             } else if (action.command !== undefined) {
-                await project.service.executeCommand(uri, action.command);
+                await this.language.service.executeCommand(uri, action.command);
             }
         } catch (error) {
             this.fail(error);

package/src/code-vision.ts

@@ -149,7 +149,7 @@ export class CodeVisionFeature {
     }
 
     private get canCount(): boolean {
-        return this.settings.usages && this.language.project.service.supports(REFERENCES, this.language.uri);
+        return this.settings.usages && this.language.service.supports(REFERENCES, this.language.uri);
     }
 
     /* Queues the declarations in view whose count is not from the current text, nearest the top of the view first. */
@@ -180,13 +180,13 @@ export class CodeVisionFeature {
     }
 
     private async count(declaration: CodeVisionDeclaration): Promise<void> {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
         const controller = new AbortController();
         this.running.set(declaration.id, controller);
         const epoch = this.epoch;
 
         try {
-            const locations = await project.service.references(uri, declaration.position, false, { signal: controller.signal, parallel: true });
+            const locations = await this.language.service.references(uri, declaration.position, false, { signal: controller.signal, parallel: true });
 
             if (!this.disposed && epoch === this.epoch) {
                 this.counts.set(declaration.id, { count: distinctPlaces(locations ?? []), epoch });