@adecore/editor-react 0.21.0 → 0.21.2

package/src/diagnostics.ts

@@ -1,8 +1,8 @@
 import type { Diagnostic } from '@adecore/lsp';
-import type { EditorContentChange, EditorPosition } from '@adecore/editor';
+import type { EditorContentChange, EditorPosition, EditorReveal } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { isShortcut } from './shortcut-keys.ts';
-import { comparePositions, markerOf, neighborProblem, problemsAt, shiftRange, type Problem } from './diagnostics-model.ts';
+import { comparePositions, markerOf, neighborProblem, problemCountsOf, problemsAt, shiftRange, type Problem } from './diagnostics-model.ts';
 
 export interface ProblemCounts {
     readonly error: number;
@@ -54,8 +54,7 @@ export class DiagnosticsFeature {
     }
 
     counts(): ProblemCounts {
-        const count = (severity: number): number => this.list.filter((problem) => (problem.diagnostic.severity ?? 1) === severity).length;
-        return { error: count(1), warning: count(2), info: count(3) };
+        return problemCountsOf(this.list.map((problem) => problem.diagnostic));
     }
 
     at(position: EditorPosition): Problem[] {
@@ -64,27 +63,23 @@ export class DiagnosticsFeature {
 
     /* Puts the caret on the next problem, or the one before; false when there is none. */
     step(direction: 1 | -1): boolean {
-        const { editor } = this.language;
-        const target = neighborProblem(this.list, editor.getCaret(), direction);
+        const caret = this.language.editor.getCaret();
+        const target = neighborProblem(this.list, caret, direction);
         if (target === null) {
             return false;
         }
-        editor.setCaret(target.diagnostic.range.start, comparePositions(target.diagnostic.range.start, editor.getCaret()) > 0 ? 'centerDown' : 'centerUp');
-        editor.focus();
-        this.language.hover.showProblemsAt(editor.getCaret());
+        const { start } = target.diagnostic.range;
+        this.reveal(start, comparePositions(start, caret) > 0 ? 'centerDown' : 'centerUp');
         return true;
     }
 
     /* Puts the caret on the first problem of the file. */
     goToFirst(): boolean {
-        const { editor } = this.language;
         const target = neighborProblem(this.list, { line: -1, character: 0 }, 1);
         if (target === null) {
             return false;
         }
-        editor.setCaret(target.diagnostic.range.start, 'center');
-        editor.focus();
-        this.language.hover.showProblemsAt(editor.getCaret());
+        this.reveal(target.diagnostic.range.start, 'center');
         return true;
     }
 
@@ -95,6 +90,13 @@ export class DiagnosticsFeature {
         };
     }
 
+    private reveal(position: EditorPosition, reveal: EditorReveal): void {
+        const { editor } = this.language;
+        editor.setCaret(position, reveal);
+        editor.focus();
+        this.language.hover.showProblemsAt(editor.getCaret());
+    }
+
     private shift(changes: readonly EditorContentChange[]): void {
         for (const [server, diagnostics] of this.reports) {
             this.reports.set(

package/src/editor-language.ts

@@ -1,5 +1,4 @@
 import { KEYMAP, type Keymap } from '@adecore/editor/keymap';
-import { shortcutsOf } from './shortcut-keys.ts';
 import type { Editor, EditorPosition } from '@adecore/editor';
 import type { Location } from '@adecore/lsp';
 import { CodeActionsFeature } from './code-actions.ts';
@@ -17,6 +16,7 @@ import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
 import { SymbolPickerFeature } from './symbol-picker.ts';
 import { RenameFeature } from './rename.ts';
+import { shortcutsOf } from './shortcut-keys.ts';
 import { createPopupStore } from './popups.ts';
 import { realTimers, type Timers } from './timers.ts';
 import { InlayHintsFeature } from './inlay-hints.ts';
@@ -95,16 +95,6 @@ export class EditorLanguage {
         this.onDispose(editor.onCaret((position) => this.placeOpenedCaret(position)));
     }
 
-    /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
-    private placeOpenedCaret(position: EditorPosition): void {
-        const column = this.project.takeCaret(this.uri, position.line);
-        if (column !== null && column.character !== position.character) {
-            this.editor.setCaret(column);
-            return;
-        }
-        this.project.noteCaret({ uri: this.uri, position });
-    }
-
     get uri(): string {
         return this.document.uri;
     }
@@ -186,4 +176,14 @@ export class EditorLanguage {
         }
         this.document.release();
     }
+
+    /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
+    private placeOpenedCaret(position: EditorPosition): void {
+        const column = this.project.takeCaret(this.uri, position.line);
+        if (column !== null && column.character !== position.character) {
+            this.editor.setCaret(column);
+            return;
+        }
+        this.project.noteCaret({ uri: this.uri, position });
+    }
 }

package/src/error-message.ts

@@ -0,0 +1,3 @@
+export function messageOf(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}

package/src/folding.ts

@@ -1,7 +1,8 @@
 import type { EditorFoldHints, EditorFoldRangeHint, EditorFoldSymbol } from '@adecore/editor';
-import type { DocumentSymbol, DocumentSymbolResult, FoldingRange, SymbolInformation } from '@adecore/lsp';
+import type { DocumentSymbolResult, FoldingRange } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
 import { Refresher } from './refresher.ts';
+import { symbolSpansOf } from './symbols.ts';
 import { realTimers, type Timers } from './timers.ts';
 
 const METHOD = 'textDocument/foldingRange';
@@ -22,33 +23,12 @@ const BODIES: Readonly<Record<number, EditorFoldSymbol['body']>> = {
     23: 'class'
 };
 
-function walk(symbols: readonly DocumentSymbol[], found: EditorFoldSymbol[]): void {
-    for (const symbol of symbols) {
-        const body = BODIES[symbol.kind];
-        if (body !== undefined && symbol.range.end.line > symbol.range.start.line) {
-            found.push({ range: symbol.range, body });
-        }
-        walk(symbol.children ?? [], found);
-    }
-}
-
 /* The symbols that have a body of more than one line, as what the editor folds them by. */
 export function foldSymbolsOf(result: DocumentSymbolResult): EditorFoldSymbol[] {
-    const found: EditorFoldSymbol[] = [];
-    if (result === null || result.length === 0) {
-        return found;
-    }
-    if ('range' in result[0]!) {
-        walk(result as DocumentSymbol[], found);
-        return found;
-    }
-    for (const symbol of result as SymbolInformation[]) {
-        const body = BODIES[symbol.kind];
-        if (body !== undefined && symbol.location.range.end.line > symbol.location.range.start.line) {
-            found.push({ range: symbol.location.range, body });
-        }
-    }
-    return found;
+    return symbolSpansOf(result).flatMap(({ kind, range }) => {
+        const body = BODIES[kind];
+        return body !== undefined && range.end.line > range.start.line ? [{ range, body }] : [];
+    });
 }
 
 /* The ranges a server folds that span more than one line, with where a range starts and ends within its lines when it says. */

package/src/history.ts

@@ -1,4 +1,5 @@
 import type { EditorLanguage } from './editor-language.ts';
+import type { Place } from './navigation-history.ts';
 import { isShortcut } from './shortcut-keys.ts';
 
 /* Back, Forward and the list of recent locations over the history the whole project shares. */
@@ -27,21 +28,11 @@ export class HistoryFeature {
 
     /* Returns to where the caret was before the last jump; false when there is no such place. */
     back(): boolean {
-        const place = this.language.project.history.back(this.language.place);
-        if (place === null) {
-            return false;
-        }
-        this.language.visit(place);
-        return true;
+        return this.visit(this.language.project.history.back(this.language.place));
     }
 
     forward(): boolean {
-        const place = this.language.project.history.forward(this.language.place);
-        if (place === null) {
-            return false;
-        }
-        this.language.visit(place);
-        return true;
+        return this.visit(this.language.project.history.forward(this.language.place));
     }
 
     /* Lists the places of the history under the caret; choosing one jumps there like any other jump. */
@@ -53,4 +44,12 @@ export class HistoryFeature {
             this.language.project.i18n.t('editor:language.history.recent')
         );
     }
+
+    private visit(place: Place | null): boolean {
+        if (place === null) {
+            return false;
+        }
+        this.language.visit(place);
+        return true;
+    }
 }

package/src/hover-content.ts

@@ -52,10 +52,12 @@ export function hoverTextOf(hover: Hover): HoverText {
     if (typeof contents === 'string' || 'language' in contents) {
         return markedStringText(contents);
     }
-    // Plain text is text, and not markdown that happens to have underscores in it.
-    return contents.kind === 'plaintext'
-        ? { signatures: [], markdown: contents.value.replace(/([\\`*_{}[\]()#+\-.!|<>~])/g, '\\$1').trim() }
-        : splitSignatures(contents.value);
+    return contents.kind === 'plaintext' ? { signatures: [], markdown: escapeMarkdown(contents.value).trim() } : splitSignatures(contents.value);
+}
+
+/* Plain text as markdown that reads the same, its markdown characters escaped. */
+export function escapeMarkdown(text: string): string {
+    return text.replace(/([\\`*_{}[\]()#+\-.!|<>~])/g, '\\$1');
 }
 
 export function isEmptyHover(text: HoverText): boolean {

package/src/hover.ts

@@ -2,6 +2,7 @@ import type { EditorHover, EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { rangeHolds, type Problem } from './diagnostics-model.ts';
 import { hoverTextOf, isEmptyHover, locationsOf } from './hover-content.ts';
+import { lineTextOf } from './line-text.ts';
 import { wordRangeAt } from './rename-model.ts';
 import type { HoverInfo } from './popups.ts';
 import { isShortcut } from './shortcut-keys.ts';
@@ -21,11 +22,11 @@ const TOAST_ID = 'language-hover';
 export class HoverFeature {
     private readonly language: EditorLanguage;
     private readonly timers: Timers;
-    private showTimer: unknown;
-    private countTimer: unknown;
     /* The counts asked for since the text last changed, by the symbol's position, so moving back to a name does not ask again. */
     private readonly counts = new Map<string, number>();
+    private showTimer: unknown;
     private hideTimer: unknown;
+    private countTimer: unknown;
     private inCard = false;
     /* Counts every request, so an answer that arrives after the pointer moved on is dropped. */
     private request = 0;
@@ -181,12 +182,15 @@ export class HoverFeature {
             service.hover(uri, position, { signal }).catch(() => null),
             service.supports('textDocument/definition', uri) ? service.definition(uri, position, { signal }).catch(() => null) : null
         ]);
-        const text = hover === null ? null : hoverTextOf(hover);
-        if (hover === null || text === null || isEmptyHover(text)) {
+        if (hover === null) {
+            return { info: null, range: null };
+        }
+        const text = hoverTextOf(hover);
+        if (isEmptyHover(text)) {
             return { info: null, range: null };
         }
         const { editor } = this.language;
-        const line = editor.textInRange({ start: { line: position.line, character: 0 }, end: { line: position.line, character: Number.MAX_SAFE_INTEGER } });
+        const line = lineTextOf(editor, position.line);
         const word = wordRangeAt(line, position);
         return {
             info: {
@@ -271,10 +275,7 @@ export class HoverFeature {
 
     /* Where the word at a position starts, which names the symbol for the cache. */
     wordStart(position: EditorPosition): number {
-        const line = this.language.editor.textInRange({
-            start: { line: position.line, character: 0 },
-            end: { line: position.line, character: Number.MAX_SAFE_INTEGER }
-        });
+        const line = lineTextOf(this.language.editor, position.line);
         return wordRangeAt(line, position)?.start.character ?? position.character;
     }
 }

package/src/inlay-hints.ts

@@ -1,6 +1,7 @@
 import type { EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
 import type { InlayHint } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
+import { lineTextOf } from './line-text.ts';
 import { Refresher } from './refresher.ts';
 import { realTimers, type Timers } from './timers.ts';
 
@@ -34,9 +35,8 @@ export function covers(asked: EditorRange, visible: EditorRange): boolean {
 }
 
 /*
- * Types and parameter names the servers infer, drawn in the text as soft pills. They are asked for the
- * lines in view and a margin around them after a pause in typing or scrolling; until the answer comes the
- * last ones stay where their text went, so nothing blinks while typing. Scrolling asks again only once the
+ * Types and parameter names the servers infer, asked for the lines in view and a margin around them. The
+ * last ones stay until the answer comes, so nothing blinks while typing; scrolling asks again only once the
  * view leaves the lines that were asked for.
  */
 export class InlayHintsFeature {
@@ -54,7 +54,7 @@ export class InlayHintsFeature {
                 }
                 const range = withMargin(editor.getVisibleRange(), editor.positionAt(Number.MAX_SAFE_INTEGER), (line) => ({
                     line,
-                    character: editor.textInRange({ start: { line, character: 0 }, end: { line, character: Number.MAX_SAFE_INTEGER } }).length
+                    character: lineTextOf(editor, line).length
                 }));
                 this.asked = range;
                 const hints = await service.inlayHints(uri, range, { signal });

package/src/language-ids.ts

@@ -1,4 +1,4 @@
-/* The highlighter ids `fs.read` answers with, by the id LSP names the same language. */
+/* Highlighter ids mapped to the LSP id of the same language. */
 const LSP_IDS: Record<string, string> = {
     typescript: 'typescript',
     tsx: 'typescriptreact',

package/src/line-text.ts

@@ -0,0 +1,10 @@
+import type { Editor, EditorPosition } from '@adecore/editor';
+
+export function lineTextOf(editor: Editor, line: number): string {
+    return editor.textInRange({ start: { line, character: 0 }, end: { line, character: Number.MAX_SAFE_INTEGER } });
+}
+
+/* The text of a position's line up to the position. */
+export function textBeforeOf(editor: Editor, position: EditorPosition): string {
+    return editor.textInRange({ start: { line: position.line, character: 0 }, end: position });
+}

package/src/navigation.ts

@@ -1,10 +1,11 @@
-import { StaleResultError, fileUriToPath, type Location, type LocationLink, type NavigationResult, type Range } from '@adecore/lsp';
+import { StaleResultError, fileUriToPath, type LanguageService, type Location, type LocationLink, type NavigationResult, type Range } from '@adecore/lsp';
 import type { EditorPosition } from '@adecore/editor';
 import { basenameOf } from './paths.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { rangeHolds } from './diagnostics-model.ts';
 import { placesOfName } from './symbol-links.ts';
 import { isShortcut } from './shortcut-keys.ts';
+import { messageOf } from './error-message.ts';
 
 export type NavigationKind = 'definition' | 'declaration' | 'typeDefinition' | 'implementation';
 
@@ -15,6 +16,13 @@ const METHODS: Record<NavigationKind, string> = {
     implementation: 'textDocument/implementation'
 };
 
+const REQUESTS: Record<NavigationKind, (service: LanguageService, uri: string, position: EditorPosition) => Promise<NavigationResult>> = {
+    definition: (service, uri, position) => service.definition(uri, position),
+    declaration: (service, uri, position) => service.declaration(uri, position),
+    typeDefinition: (service, uri, position) => service.typeDefinition(uri, position),
+    implementation: (service, uri, position) => service.implementation(uri, position)
+};
+
 const SHORTCUT_KINDS: readonly [NavigationKind, 'goToDefinition' | 'goToTypeDefinition' | 'goToImplementation'][] = [
     ['definition', 'goToDefinition'],
     ['typeDefinition', 'goToTypeDefinition'],
@@ -96,17 +104,10 @@ export class NavigationFeature {
         }
         let result: NavigationResult;
         try {
-            const { service } = project;
-            result = await (kind === 'definition'
-                ? service.definition(uri, position)
-                : kind === 'declaration'
-                  ? service.declaration(uri, position)
-                  : kind === 'typeDefinition'
-                    ? service.typeDefinition(uri, position)
-                    : service.implementation(uri, position));
+            result = await REQUESTS[kind](project.service, uri, position);
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
-                this.tell(this.say('failed', { message: error instanceof Error ? error.message : String(error) }));
+                this.tell(this.say('failed', { message: messageOf(error) }));
             }
             return;
         }

package/src/paths.ts

@@ -1,3 +1,8 @@
+/* A path inside `folder` relative to it; any other path as it is. */
+export function relativeTo(path: string, folder: string): string {
+    return path.startsWith(`${folder}/`) ? path.slice(folder.length + 1) : path;
+}
+
 export function basenameOf(path: string): string {
     return path.replaceAll('\\', '/').split('/').at(-1) ?? path;
 }

package/src/peek.ts

@@ -5,6 +5,7 @@ import { uniquePlaces } from './navigation.ts';
 import { PEEK_READ_FILES, definitionSnippetOf, peekFilesOf, snippetOf, type PeekFile } from './peek-model.ts';
 import type { PeekView } from './popups.ts';
 import { isShortcut } from './shortcut-keys.ts';
+import { messageOf } from './error-message.ts';
 
 const TOAST_ID = 'language-peek';
 /* The block as the panel draws it: a hatched band, the header, eight lines of code and a hatched band, until the editor has measured it. */
@@ -79,7 +80,7 @@ export class PeekFeature {
             found = await this.fetch(kind, position);
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
-                this.tell(this.say('failed', { message: error instanceof Error ? error.message : String(error) }));
+                this.tell(this.say('failed', { message: messageOf(error) }));
             }
             return;
         }
@@ -87,15 +88,15 @@ export class PeekFeature {
             return;
         }
         const { targets } = found;
-        const unique = found.locations.filter(
-            (location, index) =>
-                found.locations.findIndex(
-                    (other) =>
-                        other.uri === location.uri &&
-                        other.range.start.line === location.range.start.line &&
-                        other.range.start.character === location.range.start.character
-                ) === index
-        );
+        const seen = new Set<string>();
+        const unique = found.locations.filter((location) => {
+            const key = placeKey(location);
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
         if (unique.length === 0) {
             this.tell(this.say(KINDS[kind].none));
             return;

package/src/project-language.ts

@@ -5,6 +5,7 @@ import { NavigationHistory, type Place } from './navigation-history.ts';
 import { ProjectProblems } from './project-problems.ts';
 import { applyWorkspaceEdit, type ProjectFiles } from './workspace-edit.ts';
 import type { LanguageHost } from './host-types.ts';
+import { relativeTo } from './paths.ts';
 
 export interface LanguageDocumentHandle {
     readonly uri: string;
@@ -13,16 +14,16 @@ export interface LanguageDocumentHandle {
     release(): void;
 }
 
+/* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
     readonly ready: Promise<void>;
+    readonly editor: Editor;
+    private readonly service: LanguageService;
+    private readonly uri: string;
+    private readonly stop: () => void;
     private pending: ContentChange[] = [];
     private opened = false;
     private disposed = false;
-    private readonly stop: () => void;
-
-    private readonly service: LanguageService;
-    private readonly uri: string;
-    readonly editor: Editor;
 
     constructor(service: LanguageService, uri: string, languageId: string, editor: Editor) {
         this.service = service;
@@ -39,6 +40,16 @@ class DocumentSync {
         this.ready.catch(() => undefined);
     }
 
+    get text(): string {
+        return this.editor.getText();
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        this.pending = [];
+        this.stop();
+    }
+
     private changed(changes: readonly ContentChange[]): void {
         this.pending.push(...changes);
         if (this.opened) {
@@ -54,16 +65,6 @@ class DocumentSync {
         this.pending = [];
         void this.service.changeDocument(this.uri, changes).catch(() => undefined);
     }
-
-    dispose(): void {
-        this.disposed = true;
-        this.pending = [];
-        this.stop();
-    }
-
-    get text(): string {
-        return this.editor.getText();
-    }
 }
 
 interface Holder {
@@ -103,7 +104,7 @@ export class ProjectLanguage {
             return this.host.pathOfUri(uri);
         }
         const path = fileUriToPath(uri);
-        return path !== null && this.folder !== '' && path.startsWith(`${this.folder}/`) ? path.slice(this.folder.length + 1) : path;
+        return path !== null && this.folder !== '' ? relativeTo(path, this.folder) : path;
     }
 
     /* Makes an edit of a language server: an open document takes it as one undo step and any other file gets an unsaved draft. */

package/src/project-problems.ts

@@ -1,6 +1,5 @@
-import type { Diagnostic } from '@adecore/lsp';
-import type { LanguageService } from '@adecore/lsp';
-import { comparePositions, severityOf } from './diagnostics-model.ts';
+import type { Diagnostic, LanguageService } from '@adecore/lsp';
+import { comparePositions, problemCountsOf, severityOf } from './diagnostics-model.ts';
 import type { ProblemCounts } from './diagnostics.ts';
 
 /* One problem of a file and the server that reported it. */
@@ -81,7 +80,5 @@ export class ProjectProblems {
 }
 
 export function countsOf(files: readonly ProblemFile[]): ProblemCounts {
-    const rows = files.flatMap((file) => file.rows);
-    const count = (severity: number): number => rows.filter((row) => (row.diagnostic.severity ?? 1) === severity).length;
-    return { error: count(1), warning: count(2), info: count(3) };
+    return problemCountsOf(files.flatMap((file) => file.rows.map((row) => row.diagnostic)));
 }

package/src/refresher.ts

@@ -1,10 +1,9 @@
-import { StaleResultError } from '@adecore/lsp';
+import { ErrorCodes, StaleResultError } from '@adecore/lsp';
 import { realTimers, type Timers } from './timers.ts';
 
 /*
- * Asks again for something a document's text decides, such as its colors or its hints: after a pause
- * in typing, when a server says what it offers changed, and never twice at once. A newer ask aborts the
- * one before it, and an answer for a text that has moved on is dropped, since another ask is on its way.
+ * Asks again for something a document's text decides, such as its colors or hints, never twice at once.
+ * A newer ask aborts the one before it, and an answer for a text that moved on is dropped.
  */
 export class Refresher {
     private timer: unknown;
@@ -49,8 +48,15 @@ export class Refresher {
     }
 }
 
-/* The failures of a server that is not up, does not offer the feature or was asked to stop, which are not worth a line in the console. */
+const QUIET_CODES: ReadonlySet<number> = new Set([
+    ErrorCodes.ServerNotInitialized,
+    ErrorCodes.MethodNotFound,
+    ErrorCodes.RequestCancelled,
+    ErrorCodes.ContentModified
+]);
+
+/* A server that is not up, does not offer the feature or was asked to stop is not worth a line in the console. */
 function isQuiet(error: unknown): boolean {
     const code = (error as { code?: number } | null)?.code;
-    return code === -32002 || code === -32601 || code === -32800 || code === -32801;
+    return code !== undefined && QUIET_CODES.has(code);
 }

package/src/rename.ts

@@ -1,13 +1,15 @@
 import { StaleResultError, type Location, type PrepareRenameResult, type WorkspaceEdit } from '@adecore/lsp';
 import type { EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
+import { lineTextOf } from './line-text.ts';
 import type { RenameView } from './popups.ts';
 import { occurrencesOf, renamePreviewOf, renameTargetOf, wordRangeAt, type RenameTarget } from './rename-model.ts';
 import { isShortcut } from './shortcut-keys.ts';
+import { messageOf } from './error-message.ts';
 
 const METHOD = 'textDocument/rename';
 const TOAST_ID = 'language-rename';
-/* How many names are offered, and how many other lines and files are read to say how the symbol is used. */
+/* How much is read to tell a name suggester how the symbol is used: its first places, other files and lines around it. */
 const SAMPLE_LOCATIONS = 8;
 const SAMPLE_OTHER_FILES = 3;
 const CONTEXT_LINES = 3;
@@ -27,10 +29,6 @@ interface Session {
  * Edits to other files land as unsaved drafts (`applyWorkspaceEdit`), so nothing is written to disk here.
  */
 export class RenameFeature {
-    private tell(kind: 'success' | 'error', title: string): void {
-        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
-    }
-
     private readonly language: EditorLanguage;
     private session: Session | null = null;
 
@@ -80,11 +78,7 @@ export class RenameFeature {
         const target = renameTargetOf(
             answer,
             (range) => editor.textInRange(range),
-            () =>
-                wordRangeAt(
-                    editor.textInRange({ start: { line: caret.line, character: 0 }, end: { line: caret.line, character: Number.MAX_SAFE_INTEGER } }),
-                    caret
-                )
+            () => wordRangeAt(lineTextOf(editor, caret.line), caret)
         );
         if (target === null) {
             this.tell('error', this.say('nothing'));
@@ -135,7 +129,7 @@ export class RenameFeature {
             this.publish({ phase: 'preview', busy: false, name: next, files });
         } catch (error) {
             if (this.session === session) {
-                this.fail(error instanceof StaleResultError ? this.say('stale') : error instanceof Error ? error.message : String(error));
+                this.fail(error instanceof StaleResultError ? this.say('stale') : messageOf(error));
             }
         }
     }
@@ -155,6 +149,13 @@ export class RenameFeature {
         this.finish();
     }
 
+    /* The name was changed, which answers the failure under it. */
+    edited(): void {
+        if (this.language.popups.getState().rename?.error != null) {
+            this.publish({ error: null });
+        }
+    }
+
     private async apply(session: Session): Promise<void> {
         const result = await this.language.project.applyWorkspaceEdit(session.edit!);
         if (this.session !== session) {
@@ -175,13 +176,6 @@ export class RenameFeature {
         }
     }
 
-    /* The name was changed, which answers the failure under it. */
-    edited(): void {
-        if (this.language.popups.getState().rename?.error != null) {
-            this.publish({ error: null });
-        }
-    }
-
     private finish(): void {
         this.session?.names.abort();
         this.session = null;
@@ -284,6 +278,10 @@ export class RenameFeature {
         });
     }
 
+    private tell(kind: 'success' | 'error', title: string): void {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    }
+
     private say(key: string, options?: Record<string, unknown>): string {
         return this.language.project.i18n.t(`editor:language.rename.${key}`, options);
     }