The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(editor): Rainbow brackets and semantic highlighting (rainbow variables) (#59)
l0ng-aibeab7992f9de
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rsindex d3f31d929..8732351d6 100644--- a/crates/ide-core/src/settings.rs+++ b/crates/ide-core/src/settings.rs@@ -289,6 +289,11 @@ pub struct EditorSettings {pub color_scheme: String,/// Color Scheme edits: scheme id → attribute id → override.pub color_overrides: BTreeMap<String, BTreeMap<String, TextAttributesOverride>>,+ /// Color Scheme › Language Defaults › Semantic highlighting: local variables and+ /// parameters get a colour derived from their name (IDEA's rainbow identifiers).+ pub semantic_highlighting: bool,+ /// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.+ pub rainbow_brackets: bool,pub ligatures: bool,/// Fallback font for glyphs the main font lacks; empty = none.pub fallback_font: String,@@ -329,6 +334,8 @@ impl Default for EditorSettings {format_on_save: false,color_scheme: "theme-default".into(),color_overrides: BTreeMap::new(),+ semantic_highlighting: false,+ rainbow_brackets: false,ligatures: false,fallback_font: String::new(),font_weight: 400,diff --git a/docs/plugins/themes.md b/docs/plugins/themes.mdindex 3e4e550cc..cde05ac35 100644--- a/docs/plugins/themes.md+++ b/docs/plugins/themes.md@@ -195,6 +195,7 @@ The full table is `UI_KEYS` in [`scripts/theme/intellij.ts`](../../scripts/theme| `--syn-annotation`, `--syn-decorator` | `DEFAULT_METADATA` || `--syn-punct`, `--syn-escape` | `DEFAULT_OPERATION_SIGN`, `DEFAULT_VALID_STRING_ESCAPE` || `--syn-tag`, `--syn-attribute`, `--syn-todo`, `--syn-invalid` | `DEFAULT_TAG`, `DEFAULT_ATTRIBUTE`, `TODO_DEFAULT_ATTRIBUTES`, `BAD_CHARACTER` |+| `--syn-rainbow-1` … `--syn-rainbow-5` (Semantic highlighting) | `RAINBOW_COLOR1` … `RAINBOW_COLOR5` || `--wave-error`, `--wave-warning` | `ERRORS_ATTRIBUTES`, `WARNING_ATTRIBUTES` (effect colour) || `--bg-matched-brace`, `--bg-identifier-under-caret` | `MATCHED_BRACE_ATTRIBUTES`, `IDENTIFIER_UNDER_CARET_ATTRIBUTES` || `--bg-text-search-result`, `--bg-search-match` | `TEXT_SEARCH_RESULT_ATTRIBUTES`, `SEARCH_RESULT_ATTRIBUTES` |@@ -238,6 +239,7 @@ from `type`, then map:| `--fg-whitespace` | `editorWhitespace.foreground` || `--bg-text-search-result`, `--bg-text-search-result-current` | `editor.findMatchHighlightBackground`, `editor.findMatchBackground` || `--bg-matched-brace` | `editorBracketMatch.background` |+| `--syn-bracket-1` … `--syn-bracket-3` (Rainbow brackets) | `editorBracketHighlight.foreground1` … `foreground3` || `--bg-identifier-under-caret`, `-write` | `editor.wordHighlightBackground`, `editor.wordHighlightStrongBackground` || `--wave-error`, `--wave-warning` | `editorError.foreground`, `editorWarning.foreground` || `--gutter-modified`, `--gutter-added`, `--gutter-deleted` | `editorGutter.modifiedBackground`, `.addedBackground`, `.deletedBackground` |@@ -292,7 +294,7 @@ a token.<!-- BEGIN GENERATED TOKEN REFERENCE: pnpm gen:theme-docs -->-194 themeable tokens: 112 in the UI theme file, 82 in the editor colour scheme file.+202 themeable tokens: 112 in the UI theme file, 90 in the editor colour scheme file.### Surfaces (UI theme)@@ -401,6 +403,14 @@ a token.| `--syn-markup-code` | `#6aab73` | `#067d17` || `--syn-invalid` | `#f75464` | `#f50000` || `--syn-inline-value` | `#868a91` | `#8c8c8c` |+| `--syn-rainbow-1` | `#6fafbd` | `#9b3b6a` |+| `--syn-rainbow-2` | `#d79b6e` | `#114d77` |+| `--syn-rainbow-3` | `#9fbf6b` | `#9c6a2c` |+| `--syn-rainbow-4` | `#c98bc6` | `#005910` |+| `--syn-rainbow-5` | `#8e9cf0` | `#bc5150` |+| `--syn-bracket-1` | `#e8c25b` | `#0431fa` |+| `--syn-bracket-2` | `#d78bd6` | `#319331` |+| `--syn-bracket-3` | `#4ea7f0` | `#7b3814` |### Editor (editor scheme)diff --git a/scripts/theme/intellij.ts b/scripts/theme/intellij.tsindex c9b35e162..1fb828b95 100644--- a/scripts/theme/intellij.ts+++ b/scripts/theme/intellij.ts@@ -135,6 +135,11 @@ export const ICLS_ATTRIBUTES: Record<string, Array<[Part, string]>> = {DEFAULT_ATTRIBUTE: [["FOREGROUND", "--syn-attribute"]],TODO_DEFAULT_ATTRIBUTES: [["FOREGROUND", "--syn-todo"]],BAD_CHARACTER: [["FOREGROUND", "--syn-invalid"]],+ RAINBOW_COLOR1: [["FOREGROUND", "--syn-rainbow-1"]],+ RAINBOW_COLOR2: [["FOREGROUND", "--syn-rainbow-2"]],+ RAINBOW_COLOR3: [["FOREGROUND", "--syn-rainbow-3"]],+ RAINBOW_COLOR4: [["FOREGROUND", "--syn-rainbow-4"]],+ RAINBOW_COLOR5: [["FOREGROUND", "--syn-rainbow-5"]],ERRORS_ATTRIBUTES: [["EFFECT_COLOR", "--wave-error"]],WARNING_ATTRIBUTES: [["EFFECT_COLOR", "--wave-warning"]],NOT_USED_ELEMENT_ATTRIBUTES: [["FOREGROUND", "--fg-unused"]],diff --git a/src/bindings.ts b/src/bindings.tsindex 853cb8822..c76ff5c57 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -2016,6 +2016,13 @@ export type EditorSettings_Deserialize = {colorScheme?: string,/** Color Scheme edits: scheme id → attribute id → override. */colorOverrides?: { [key in string]: { [key in string]: TextAttributesOverride_Deserialize } },+ /**+ * Color Scheme › Language Defaults › Semantic highlighting: local variables and+ * parameters get a colour derived from their name (IDEA's rainbow identifiers).+ */+ semanticHighlighting?: boolean,+ /** Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth. */+ rainbowBrackets?: boolean,ligatures?: boolean,/** Fallback font for glyphs the main font lacks; empty = none. */fallbackFont?: string,@@ -2056,6 +2063,13 @@ export type EditorSettings_Serialize = {colorScheme: string,/** Color Scheme edits: scheme id → attribute id → override. */colorOverrides: { [key in string]: { [key in string]: TextAttributesOverride_Serialize } },+ /**+ * Color Scheme › Language Defaults › Semantic highlighting: local variables and+ * parameters get a colour derived from their name (IDEA's rainbow identifiers).+ */+ semanticHighlighting: boolean,+ /** Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth. */+ rainbowBrackets: boolean,ligatures: boolean,/** Fallback font for glyphs the main font lacks; empty = none. */fallbackFont: string,diff --git a/src/editor/core/actions.ts b/src/editor/core/actions.tsindex f03ac4f82..e2c9727ae 100644--- a/src/editor/core/actions.ts+++ b/src/editor/core/actions.ts@@ -40,6 +40,9 @@ import { useDocMeta, useOutline } from "./model/document";import { fontZoom, setFontZoom } from "./cm/prefs";import { useEditorRegistry } from "@/editor/api";import { useProject } from "@/platform/project";+import { call, commands } from "@/platform/ipc";+import { editorPrefs } from "@/platform/editorSettings";+import { notifications } from "@/workbench/contributions";import { toggleReadOnly } from "./fileAttributes";import { openNavBarPopup } from "./view/NavBarPopup";import {@@ -298,6 +301,26 @@ function addNextOccurrence(view: EditorView) {if (nextOccurrence(view) === "notFound") void executeAction("editor.showHint", { text: "Not found, press again to search from the top" });}+/** Settings › Editor › Color Scheme switches that are also toggle actions. */+type SchemeSwitch = "semanticHighlighting" | "rainbowBrackets";++export async function toggleSchemeSwitch(key: SchemeSwitch, on = !editorPrefs()[key]): Promise<void> {+ try {+ useProject.setState({ settings: await call(commands.settingsSet("global", `editor.${key}`, JSON.stringify(on))) });+ } catch (e) {+ notifications().notify({ level: "error", title: "Cannot change the setting", body: e instanceof Error ? e.message : String(e) });+ }+}++const schemeSwitch = (id: string, title: string, key: SchemeSwitch, keywords: string[]): Action => ({+ id,+ title,+ category: "Editor",+ keywords,+ toggled: () => editorPrefs()[key],+ run: () => toggleSchemeSwitch(key),+});+// ---------------------------------------------------------------------------------export function registerEditorActions(): () => void {@@ -316,6 +339,16 @@ export function registerEditorActions(): () => void {return pane?.active ? { paneId: pane.id, tabId: pane.active } : null;};return registerActions([+ schemeSwitch("editor.toggleSemanticHighlighting", "Semantic Highlighting", "semanticHighlighting", [+ "rainbow variables",+ "rainbow identifiers",+ "color scheme",+ ]),+ schemeSwitch("editor.toggleRainbowBrackets", "Rainbow Brackets", "rainbowBrackets", [+ "bracket pair colorization",+ "rainbow parentheses",+ "color scheme",+ ]),text("code.commentLine", "Comment with Line Comment", (v) => commentLine(v)),text("code.commentBlock", "Comment with Block Comment", (v) => toggleBlockComment(v)),text("code.duplicateLine", "Duplicate Line or Selection", (v) => duplicateLineOrSelection(v)),diff --git a/src/editor/core/cm/rainbowBrackets.test.ts b/src/editor/core/cm/rainbowBrackets.test.tsnew file mode 100644index 000000000..9b325d155--- /dev/null+++ b/src/editor/core/cm/rainbowBrackets.test.ts@@ -0,0 +1,95 @@+import { describe, expect, it } from "vitest";+import { EditorState, type Extension } from "@codemirror/state";+import { EditorView } from "@codemirror/view";+import { ensureSyntaxTree } from "@codemirror/language";+import { languages } from "@codemirror/language-data";+import { BracketScanner, bracketClass } from "./rainbowBrackets";+import { heavyExtension } from "./setup";+import type { EditorSettings } from "@/platform/ipc";++const cStyle = EditorState.languageData.of(() => [+ { commentTokens: { line: "//", block: { open: "/*", close: "*/" } } },+]);++/** `char@depth` of every coloured bracket (`!` for unmatched). */+function marks(doc: string, ext: Extension = [], from = 0, to = doc.length, scanner = new BracketScanner()) {+ const state = EditorState.create({ doc, extensions: ext });+ ensureSyntaxTree(state, doc.length, 5000);+ return scanner.marks(state, from, to).map((m) => `${doc[m.from]}${m.depth < 0 ? "!" : m.depth}`);+}++const javascript = () => languages.find((l) => l.name === "JavaScript")!.load();++describe("rainbow brackets", () => {+ it("colours brackets by nesting depth, cycling through the palette", () => {+ expect(marks("f(a[b{c}d]e)")).toEqual(["(0", "[1", "{2", "}2", "]1", ")0"]);+ expect([0, 1, 2, 3, 4].map(bracketClass)).toEqual([+ "cm-rainbow-bracket-1",+ "cm-rainbow-bracket-2",+ "cm-rainbow-bracket-3",+ "cm-rainbow-bracket-1",+ "cm-rainbow-bracket-2",+ ]);+ });++ it("marks unmatched and mismatched brackets", () => {+ expect(marks("a)b")).toEqual([")!"]);+ expect(marks("(]")).toEqual(["(!", "]!"]);+ expect(marks("x(y")).toEqual(["(!"]);+ expect(marks("((a)")).toEqual(["(!", "(1", ")1"]);+ expect(bracketClass(-1)).toBe("cm-rainbow-bracket-unmatched");+ });++ it("skips strings and comments lexically when there is no syntax tree", () => {+ const doc = "f(\"(\", '[', `{\n)`) // (\n/* ] */ g()";+ expect(marks(doc, cStyle)).toEqual(["(0", ")0", "(0", ")0"]);+ // Primes and lifetimes are not quotes.+ expect(marks("f x' = (x', y)", cStyle)).toEqual(["(0", ")0"]);+ });++ it("skips strings, comments and regexps with the syntax tree", async () => {+ const doc = 'f("(", /[(]/, `{`) // )\n/* ] */ g([1, {a: 2}])';+ expect(marks(doc, await javascript())).toEqual(["(0", ")0", "(0", "[1", "{2", "}2", "]1", ")0"]);+ });++ it("knows the depth at a viewport far into the document and after edits", () => {+ const body = "x(y)\n".repeat(5000);+ const doc = `{\n${body}[z]\n}`;+ const scanner = new BracketScanner();+ const at = doc.indexOf("[z]");+ expect(marks(doc, cStyle, at, doc.length, scanner)).toEqual(["[1", "]1", "}0"]);+ // Checkpoints make the rescan start near the viewport; an edit before it invalidates them.+ let state = EditorState.create({ doc, extensions: cStyle });+ const tr = state.update({ changes: { from: 100, insert: "(" } });+ scanner.invalidate(100);+ state = tr.state;+ const from = at + 1;+ expect(+ scanner+ .marks(state, from, state.doc.length)+ .map((m) => `${state.doc.sliceString(m.from, m.from + 1)}${m.depth < 0 ? "!" : m.depth}`),+ ).toEqual(["[2", "]2", "}!"]);+ });++ it("is installed by the Rainbow brackets setting", () => {+ const render = (rainbowBrackets: boolean) => {+ const view = new EditorView({+ state: EditorState.create({+ doc: "f(a[b])",+ extensions: [cStyle, heavyExtension(7, { rainbowBrackets } as unknown as EditorSettings)],+ }),+ parent: document.body,+ });+ const classes = [...view.contentDOM.querySelectorAll("[class*=cm-rainbow-bracket]")].map((e) => e.className);+ view.destroy();+ return classes;+ };+ expect(render(false)).toEqual([]);+ expect(render(true)).toEqual([+ "cm-rainbow-bracket-1",+ "cm-rainbow-bracket-2",+ "cm-rainbow-bracket-2",+ "cm-rainbow-bracket-1",+ ]);+ });+});diff --git a/src/editor/core/cm/rainbowBrackets.ts b/src/editor/core/cm/rainbowBrackets.tsnew file mode 100644index 000000000..3cc99e20a--- /dev/null+++ b/src/editor/core/cm/rainbowBrackets.ts@@ -0,0 +1,309 @@+/**+ * Rainbow brackets (VS Code's bracket pair colorization): `()`, `[]`, `{}`+ * coloured by nesting depth (`--syn-bracket-<n>`, cycling), unmatched ones in+ * the error colour. Strings and comments are skipped: with the syntax tree+ * when the language has one, else lexically with the language's comment+ * tokens and quotes.+ *+ * Only the viewport is decorated. The nesting state at its start comes from+ * checkpoints saved every few KB while scanning, so scrolling and typing+ * rescan from the nearest checkpoint before the change, not from the top.+ */+import { Prec, type EditorState, type Extension, type Text } from "@codemirror/state";+import { Decoration, ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";+import { syntaxTree } from "@codemirror/language";++type Tree = ReturnType<typeof syntaxTree>;+type NodeType = Tree["type"];++/** Number of `--syn-bracket-<n>` colours the depth cycles through. */+export const BRACKET_COLORS = 3;++const CHUNK = 4096;+/** How far past the viewport to look for the closers of visible openers. */+const LOOKAHEAD = 64_000;+/** Longest comment / quote token the lexical scanner needs to see past a chunk end. */+const TOKEN_SLACK = 8;++/** Closer char code of each opener char code: `(` `[` `{`. */+const CLOSER: Record<number, number> = { 40: 41, 91: 93, 123: 125 };++/** An open bracket; the stack is a persistent list so checkpoints can share it. */+interface Opener {+ closer: number;+ pos: number;+ depth: number;+ prev: Opener | null;+}++/** Lexical mode: code, line comment, block comment, string (quote in `quote`). */+type Mode = 0 | 1 | 2 | 3;++interface ScanState {+ pos: number;+ stack: Opener | null;+ mode: Mode;+ quote: string;+}++export interface BracketMark {+ from: number;+ /** 0-based depth, or -1 for an unmatched bracket. */+ depth: number;+}++interface CommentTokens {+ line?: string;+ block?: { open: string; close: string };+}++const SKIP_NODE = /string|comment|char|rune|regexp|textblock|docstring|heredoc/i;+const skipCache = new WeakMap<NodeType, boolean>();+function skipsNode(type: NodeType): boolean {+ let v = skipCache.get(type);+ if (v === undefined) skipCache.set(type, (v = !type.isTop && SKIP_NODE.test(type.name)));+ return v;+}++/**+ * Bracket scanner of one editor: keeps the checkpoints between rebuilds and+ * drops the ones after an edit (`invalidate`).+ */+export class BracketScanner {+ private checkpoints: ScanState[] = [];+ private tree: Tree | null = null;++ /** Forget checkpoints after `pos` (first changed position of the old document). */+ invalidate(pos: number) {+ const keep = pos - TOKEN_SLACK;+ let n = this.checkpoints.length;+ while (n > 0 && this.checkpoints[n - 1]!.pos > keep) n--;+ this.checkpoints.length = n;+ }++ /** Brackets in `[from, to)` with their depth; unmatched ones get depth -1. */+ marks(state: EditorState, from: number, to: number): BracketMark[] {+ const tree = treeOf(state);+ if (tree !== this.tree) {+ // A grown tree may reinterpret what was past its old end.+ if (this.tree && tree) this.invalidate(Math.min(this.tree.length, tree.length));+ else this.checkpoints.length = 0;+ this.tree = tree;+ }+ const doc = state.doc;+ to = Math.min(to, doc.length);+ const limit = tree ? Math.min(doc.length, tree.length) : doc.length;+ const comments = tree ? {} : (state.languageDataAt<CommentTokens>("commentTokens", 0)[0] ?? {});+ const out: BracketMark[] = [];+ const s = this.start(from);+ const visit = (pos: number, depth: number) => {+ if (pos >= from && pos < to) out.push({ from: pos, depth });+ };+ this.scan(doc, tree, comments, s, Math.min(to, limit), visit);+ // Visible openers whose closer never comes are unmatched; give up (leave them coloured) past the lookahead.+ let open = s.stack;+ let shallowest = Infinity;+ for (let o = open; o && o.pos >= from; o = o.prev) shallowest = o.depth;+ if (shallowest !== Infinity) {+ const end = Math.min(limit, to + LOOKAHEAD);+ this.scan(doc, tree, comments, s, end, () => {}, shallowest);+ open = s.stack;+ if (s.pos >= doc.length && (open?.depth ?? -1) >= shallowest) {+ const unmatched = new Set<number>();+ for (let o = open; o && o.depth >= shallowest; o = o.prev) unmatched.add(o.pos);+ for (const m of out) if (unmatched.has(m.from)) m.depth = -1;+ }+ }+ return out;+ }++ private start(from: number): ScanState {+ const cps = this.checkpoints;+ let lo = 0;+ let hi = cps.length - 1;+ let best = -1;+ while (lo <= hi) {+ const mid = (lo + hi) >> 1;+ if (cps[mid]!.pos <= from) {+ best = mid;+ lo = mid + 1;+ } else hi = mid - 1;+ }+ return best < 0 ? { pos: 0, stack: null, mode: 0, quote: "" } : { ...cps[best]! };+ }++ /**+ * Advances `s` to `end`, calling `visit` for every bracket. With `untilBelow`,+ * stops once the stack is shallower than that depth (lookahead).+ */+ private scan(+ doc: Text,+ tree: Tree | null,+ comments: CommentTokens,+ s: ScanState,+ end: number,+ visit: (pos: number, depth: number) => void,+ untilBelow = -1,+ ) {+ const cps = this.checkpoints;+ const lineFirst = comments.line ? comments.line.charCodeAt(0) : -1;+ const blockFirst = comments.block ? comments.block.open.charCodeAt(0) : -1;+ while (s.pos < end) {+ const chunkEnd = Math.min(end, (Math.floor(s.pos / CHUNK) + 1) * CHUNK);+ const base = s.pos;+ const text = doc.sliceString(base, Math.min(doc.length, chunkEnd + TOKEN_SLACK));+ const stop = chunkEnd - base;+ const skips: number[] = [];+ if (tree)+ tree.iterate({+ from: base,+ to: chunkEnd,+ enter: (n) => {+ if (!skipsNode(n.type)) return;+ skips.push(n.from - base, n.to - base);+ return false;+ },+ });+ let k = 0;+ let i = 0;+ while (i < stop) {+ if (tree) {+ while (k < skips.length && skips[k + 1]! <= i) k += 2;+ if (k < skips.length && skips[k]! <= i) {+ i = skips[k + 1]!;+ continue;+ }+ } else if (s.mode !== 0) {+ i = lexSkip(text, i, stop, s, comments);+ continue;+ }+ const ch = text.charCodeAt(i);+ if (!tree && (ch === 34 || ch === 39 || ch === 96 || ch === lineFirst || ch === blockFirst)) {+ const next = lexEnter(text, i, s, comments);+ if (next !== i) {+ i = next;+ continue;+ }+ }+ if (ch === 40 || ch === 91 || ch === 123) {+ const depth = s.stack ? s.stack.depth + 1 : 0;+ visit(base + i, depth);+ s.stack = { closer: CLOSER[ch]!, pos: base + i, depth, prev: s.stack };+ } else if (ch === 41 || ch === 93 || ch === 125) {+ if (s.stack && s.stack.closer === ch) {+ visit(base + i, s.stack.depth);+ s.stack = s.stack.prev;+ if ((s.stack?.depth ?? -1) < untilBelow) {+ s.pos = base + i + 1;+ return;+ }+ } else visit(base + i, -1);+ }+ i++;+ }+ s.pos = base + i;+ const last = cps[cps.length - 1];+ if (s.pos >= (last ? last.pos : 0) + CHUNK && s.pos <= doc.length) cps.push({ ...s });+ }+ }+}++/** The syntax tree when the editor has a language, else null (lexical scanning). */+function treeOf(state: EditorState): Tree | null {+ const tree = syntaxTree(state);+ return tree.length || state.doc.length === 0 ? tree : null;+}++/** In code at `i`: enters a comment / string and returns the index after its opening token, else `i`. */+function lexEnter(text: string, i: number, s: ScanState, c: CommentTokens): number {+ const ch = text[i]!;+ if (c.line && text.startsWith(c.line, i)) {+ s.mode = 1;+ return i + c.line.length;+ }+ if (c.block && text.startsWith(c.block.open, i)) {+ s.mode = 2;+ return i + c.block.open.length;+ }+ if (ch === '"' || ch === "`" || (ch === "'" && quoteStartsString(text, i))) {+ s.mode = 3;+ s.quote = ch;+ return i + 1;+ }+ return i;+}++/** `'` starts a string unless it ends a word (Haskell's `x'`) or has no partner on the line (Rust lifetimes). */+function quoteStartsString(text: string, i: number): boolean {+ if (i > 0 && /[\w]/.test(text[i - 1]!)) return false;+ const nl = text.indexOf("\n", i + 1);+ const close = text.indexOf("'", i + 1);+ return close >= 0 && (nl < 0 || close < nl);+}++/** Inside a comment / string at `i`: the index after its end (back in code), else `stop` (still inside). */+function lexSkip(text: string, i: number, stop: number, s: ScanState, c: CommentTokens): number {+ if (s.mode === 1 || s.mode === 2) {+ const close = s.mode === 1 ? "\n" : (c.block?.close ?? "\n");+ const at = text.indexOf(close, i);+ if (at < 0 || at >= stop) return stop;+ s.mode = 0;+ return at + close.length;+ }+ for (; i < stop; i++) {+ const ch = text[i];+ if (ch === "\\") i++;+ else if (ch === s.quote || (ch === "\n" && s.quote !== "`")) {+ s.mode = 0;+ return i + 1;+ }+ }+ return i;+}++/** Class of a bracket at `depth` (-1: unmatched); the palette repeats every `BRACKET_COLORS` levels. */+export function bracketClass(depth: number): string {+ return depth < 0 ? "cm-rainbow-bracket-unmatched" : `cm-rainbow-bracket-${(depth % BRACKET_COLORS) + 1}`;+}++const markCache = new Map<string, Decoration>();+function markFor(depth: number): Decoration {+ const cls = bracketClass(depth);+ let m = markCache.get(cls);+ if (!m) markCache.set(cls, (m = Decoration.mark({ class: cls })));+ return m;+}++function build(view: EditorView, scanner: BracketScanner): DecorationSet {+ const { from, to } = view.viewport;+ return Decoration.set(+ scanner.marks(view.state, from, to).map((m) => markFor(m.depth).range(m.from, m.from + 1)),+ true,+ );+}++const plugin = ViewPlugin.fromClass(+ class {+ scanner = new BracketScanner();+ decorations: DecorationSet;+ constructor(view: EditorView) {+ this.decorations = build(view, this.scanner);+ }+ update(u: ViewUpdate) {+ if (u.docChanged) {+ let first = Infinity;+ u.changes.iterChangedRanges((fromA) => (first = Math.min(first, fromA)));+ this.scanner.invalidate(first);+ }+ if (u.docChanged || u.viewportChanged || syntaxTree(u.startState) !== syntaxTree(u.state))+ this.decorations = build(u.view, this.scanner);+ }+ },+ { decorations: (v) => v.decorations },+);++/** Rainbow brackets for one editor (Settings › Editor › Color Scheme › Rainbow brackets). */+export function rainbowBrackets(): Extension {+ // Above the syntax highlighter so the bracket colour is the innermost span.+ return Prec.high(plugin);+}diff --git a/src/editor/core/cm/setup.ts b/src/editor/core/cm/setup.tsindex 4a47ce40b..b25a4184f 100644--- a/src/editor/core/cm/setup.ts+++ b/src/editor/core/cm/setup.ts@@ -36,6 +36,7 @@ import { changeLane, overviewLane } from "./lanes";import { foldingExtension } from "./folding";import { syntaxHighlightField } from "./syntaxHighlight";import { indentGuides } from "./indentGuides";+import { rainbowBrackets } from "./rainbowBrackets";import { stickyMaxLines, stickyScroll } from "./stickyScroll";import { findExtension } from "./find";import { codeLensExtension } from "./codeLens";@@ -204,6 +205,7 @@ export function heavyExtension(docLength: number, settings?: EditorSettings): Exreturn [prefs.codeEditing.highlightBraces ? bracketMatching({ renderMatch }) : [],prefs.appearance.indentGuides ? indentGuides : [],+ prefs.rainbowBrackets ? rainbowBrackets() : [],prefs.codeEditing.highlightSelection ? highlightSelectionMatches({ minSelectionLength: 2, maxMatches: 500 }) : [],];}diff --git a/src/editor/core/cm/theme.ts b/src/editor/core/cm/theme.tsindex a0d46311c..f053ee393 100644--- a/src/editor/core/cm/theme.ts+++ b/src/editor/core/cm/theme.ts@@ -6,6 +6,7 @@* ones are read through `--editor-*` locals with fallbacks to the base tokens.*/import { EditorView } from "@codemirror/view";+import { BRACKET_COLORS } from "./rainbowBrackets";export const openideaTheme = EditorView.theme({"&": {@@ -158,6 +159,19 @@ export const openideaTheme = EditorView.theme({backgroundPosition: "6px 0",},+ // Rainbow brackets (cm/rainbowBrackets.ts); `*` too: the syntax highlighter's span sits inside and would win.+ ...Object.fromEntries(+ Array.from({ length: BRACKET_COLORS }, (_, i) => [+ `.cm-rainbow-bracket-${i + 1}, .cm-rainbow-bracket-${i + 1} *`,+ {+ color: `var(--syn-bracket-${i + 1})`,+ fontWeight: `var(--syn-bracket-${i + 1}-bold, inherit)`,+ fontStyle: `var(--syn-bracket-${i + 1}-italic, inherit)`,+ },+ ]),+ ),+ ".cm-rainbow-bracket-unmatched, .cm-rainbow-bracket-unmatched *": { color: "var(--syn-invalid)" },+// Whitespace rendering".cm-highlightSpace": {backgroundImage: "radial-gradient(circle at 50% 55%, var(--fg-whitespace, var(--fg-faint)) 11%, transparent 12%)",diff --git a/src/editor/lsp/features.test.ts b/src/editor/lsp/features.test.tsindex 1f40be531..1f23db661 100644--- a/src/editor/lsp/features.test.ts+++ b/src/editor/lsp/features.test.ts@@ -1,7 +1,7 @@import { describe, expect, it } from "vitest";import { Text } from "@codemirror/state";import type { CodeAction } from "@/bindings";-import { semanticRanges } from "./semantic";+import { RAINBOW_COLORS, rainbowIndex, semanticRanges } from "./semantic";import { lineErrorsAwayFromCaret, sortCodeActions } from "./intentions";import { splitSignature } from "./signature";import { dedupeLocations, usagesStatusText } from "./navigation";@@ -28,6 +28,66 @@ describe("semanticRanges", () => {});});+describe("semantic highlighting (rainbow identifiers)", () => {+ // fn f(total: u32, self) { let count = total; static S; obj.field; count }+ const doc = Text.of(["fn f(total, self) { let count = total; S; obj.field; count + total }"]);+ const tokens = {+ tokenTypes: ["variable", "parameter", "property", "selfParameter"],+ tokenModifiers: ["static", "declaration"],+ data: [+ [0, 5, 5, 1, 0b10], // total (parameter declaration)+ [0, 12, 4, 3, 0], // self+ [0, 24, 5, 0, 0b10], // count+ [0, 32, 5, 1, 0], // total+ [0, 39, 1, 0, 0b01], // S (static)+ [0, 42, 3, 0, 0], // obj+ [0, 46, 5, 2, 0], // field+ [0, 53, 5, 0, 0], // count+ [0, 61, 5, 1, 0], // total+ ].flat(),+ };+ const rainbow = (r: { className: string }) => /cm-sem-rainbow-(\d)/.exec(r.className)?.[1] ?? null;++ it("hashes names to a stable palette index", () => {+ expect(rainbowIndex("count")).toBe(rainbowIndex("count"));+ const all = ["a", "b", "count", "total", "index", "value", "name", "item", "result", "i", "j", "k"].map(rainbowIndex);+ for (const n of all) expect(n >= 1 && n <= RAINBOW_COLORS).toBe(true);+ expect(new Set(all).size).toBeGreaterThan(2);+ });++ it("colours locals and parameters by name, only when enabled", () => {+ expect(semanticRanges(doc, tokens).some((r) => rainbow(r))).toBe(false);+ const ranges = semanticRanges(doc, tokens, true);+ const byText = new Map<string, Set<string | null>>();+ for (const r of ranges) {+ const name = doc.sliceString(r.from, r.to);+ byText.set(name, (byText.get(name) ?? new Set()).add(rainbow(r)));+ }+ expect(byText.get("total")).toEqual(new Set([String(rainbowIndex("total"))]));+ expect(byText.get("count")).toEqual(new Set([String(rainbowIndex("count"))]));+ expect(byText.get("obj")).toEqual(new Set([String(rainbowIndex("obj"))]));+ // Parameters keep their own class too; self, statics and fields get no rainbow colour.+ expect(ranges.find((r) => r.from === 5)!.className).toBe(`cm-sem-parameter cm-sem-declaration cm-sem-rainbow-${rainbowIndex("total")}`);+ expect(byText.get("self")).toEqual(new Set([null]));+ expect(byText.get("S")).toEqual(new Set([null]));+ expect(byText.get("field")).toEqual(new Set([null]));+ });++ it("leaves module-level variables plain when the server marks locals", () => {+ const ts = Text.of(["let top = 1; function f(p) { let x = top + p; }"]);+ const r = semanticRanges(+ ts,+ {+ tokenTypes: ["variable", "parameter"],+ tokenModifiers: ["declaration", "local"],+ data: [0, 4, 3, 0, 0b01, 0, 24, 1, 1, 0b11, 0, 33, 1, 0, 0b11, 0, 37, 3, 0, 0, 0, 43, 1, 1, 0b10],+ },+ true,+ );+ expect(r.filter((x) => x.className.includes("rainbow")).map((x) => ts.sliceString(x.from, x.to))).toEqual(["p", "x", "p"]);+ });+});+describe("sortCodeActions", () => {const a = (title: string, kind: string | null, isPreferred = false, disabledReason: string | null = null): CodeAction => ({title,diff --git a/src/editor/lsp/semantic.ts b/src/editor/lsp/semantic.tsindex 2a11eeee9..5ab2a19fb 100644--- a/src/editor/lsp/semantic.ts+++ b/src/editor/lsp/semantic.ts@@ -3,10 +3,16 @@* `cm-sem-*` classes (styled with the --syn-* tokens) layered over the Lezer* highlighting. Refreshed after edits (debounced); in between, existing marks* are mapped through the changes.+ *+ * Semantic highlighting (Color Scheme › Language Defaults, IDEA's rainbow+ * identifiers): local variables and parameters additionally get+ * `cm-sem-rainbow-<n>`, `n` derived from the name, so one name keeps one+ * colour (`--syn-rainbow-<n>`) throughout the file.*/import { Prec, StateEffect, StateField, type Extension, type Text } from "@codemirror/state";import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";import { commands, type SemanticTokens } from "@/platform/ipc";+import { editorPrefs } from "@/platform/editorSettings";import { debounce, docOf, isUnavailable, lspRequest } from "./lsp";import { onLspRefresh, serverBackoff } from "./availability";@@ -50,6 +56,23 @@ const MODIFIER_CLASS: Record<string, string> = {defaultLibrary: "builtin",};+/** Number of `--syn-rainbow-<n>` colours (IDEA's five semantic highlighting colours). */+export const RAINBOW_COLORS = 5;++/** Stable 1-based palette index of an identifier (FNV-1a over its UTF-16 units). */+export function rainbowIndex(name: string): number {+ let h = 0x811c9dc5;+ for (let i = 0; i < name.length; i++) {+ h ^= name.charCodeAt(i);+ h = Math.imul(h, 0x01000193);+ }+ return ((h >>> 0) % RAINBOW_COLORS) + 1;+}++/** Locals and parameters only: no fields, statics, constants, library or `self` names. */+const RAINBOW_TYPES = new Set(["variable", "parameter"]);+const NOT_LOCAL = new Set(["static", "constant", "defaultLibrary", "global", "classScope", "fileScope"]);+export interface SemanticRange {from: number;to: number;@@ -57,9 +80,11 @@ export interface SemanticRange {}/** Decodes absolute `[line, col, len, type, modifiers]` quintuples into styled ranges. */-export function semanticRanges(doc: Text, tokens: SemanticTokens): SemanticRange[] {+export function semanticRanges(doc: Text, tokens: SemanticTokens, rainbow = false): SemanticRange[] {const out: SemanticRange[] = [];const { data, tokenTypes, tokenModifiers } = tokens;+ // Servers with a `local` modifier (TypeScript) tell module-level variables apart.+ const marksLocals = tokenModifiers.includes("local");for (let i = 0; i + 4 < data.length; i += 5) {const line = data[i]!,col = data[i + 1]!,@@ -77,11 +102,19 @@ export function semanticRanges(doc: Text, tokens: SemanticTokens): SemanticRangeif (constant && (type === "variable" || type === "property")) base = "constant";if (base && base !== "variable") classes.push(`cm-sem-${base}`);for (const n of names) if (MODIFIER_CLASS[n]) classes.push(`cm-sem-${MODIFIER_CLASS[n]}`);- if (!classes.length) continue;+ const local =+ rainbow &&+ !constant &&+ RAINBOW_TYPES.has(type) &&+ !names.some((n) => NOT_LOCAL.has(n)) &&+ (type === "parameter" || !marksLocals || names.includes("local"));+ if (!classes.length && !local) continue;const l = doc.line(line + 1);const from = l.from + Math.min(col, l.length);const to = Math.min(from + len, l.to);- if (from < to) out.push({ from, to, className: classes.join(" ") });+ if (from >= to) continue;+ if (local) classes.push(`cm-sem-rainbow-${rainbowIndex(doc.sliceString(from, to))}`);+ out.push({ from, to, className: classes.join(" ") });}return out.sort((a, b) => a.from - b.from || a.to - b.to);}@@ -107,12 +140,33 @@ const semanticPlugin = ViewPlugin.fromClass(class {private refresh = debounce(() => void this.run(), 600);private offReady: () => void;+ private rainbow = editorPrefs().semanticHighlighting;+ /** Last answer, re-decorated without a request when Semantic highlighting is toggled. */+ private last: { doc: Text; tokens: SemanticTokens | null } | null = null;+ private destroyed = false;constructor(private view: EditorView) {this.refresh();this.offReady = onLspRefresh("semanticTokens", () => this.refresh());}update(u: ViewUpdate) {if (u.docChanged) this.refresh();+ const rainbow = editorPrefs().semanticHighlighting;+ if (rainbow === this.rainbow) return;+ this.rainbow = rainbow;+ const last = this.last;+ // Settings arrive as a compartment reconfiguration; no dispatching inside an update.+ if (last && last.doc === u.state.doc)+ queueMicrotask(() => {+ if (!this.destroyed && this.view.state.doc === last.doc) this.decorate(last.doc, last.tokens);+ });+ else this.refresh();+ }+ decorate(doc: Text, tokens: SemanticTokens | null) {+ this.last = { doc, tokens };+ const ranges = tokens ? semanticRanges(doc, tokens, this.rainbow) : [];+ this.view.dispatch({+ effects: setSemantic.of(Decoration.set(ranges.map((r) => markFor(r.className).range(r.from, r.to)), true)),+ });}async run() {const view = this.view;@@ -122,15 +176,13 @@ const semanticPlugin = ViewPlugin.fromClass(try {const tokens = await lspRequest(() => commands.lspSemanticTokens(doc.doc));if (view.state.doc !== state.doc) return this.refresh();- const ranges = tokens ? semanticRanges(state.doc, tokens) : [];- view.dispatch({- effects: setSemantic.of(Decoration.set(ranges.map((r) => markFor(r.className).range(r.from, r.to)), true)),- });+ this.decorate(state.doc, tokens);} catch (e) {if (isUnavailable(e)) serverBackoff.mark(doc.doc);}}destroy() {+ this.destroyed = true;this.refresh.cancel();this.offReady();}diff --git a/src/editor/lsp/theme.ts b/src/editor/lsp/theme.tsindex 1fb6d96d3..b04640910 100644--- a/src/editor/lsp/theme.ts+++ b/src/editor/lsp/theme.ts@@ -1,5 +1,6 @@/** Editor-side styling for LSP features (CodeMirror theme; tokens only). */import { EditorView } from "@codemirror/view";+import { RAINBOW_COLORS } from "./semantic";const tooltipSurface = {backgroundColor: "var(--bg-popup)",@@ -350,6 +351,18 @@ export const lspTheme = EditorView.theme({".cm-sem-static": { fontStyle: "italic" },".cm-sem-mutable": { textDecoration: "underline", textDecorationColor: "var(--fg-faint)", textUnderlineOffset: "3px" },".cm-sem-deprecated": { textDecoration: "line-through" },+ // Semantic highlighting: after the base classes so a parameter's colour gives way, and over the+ // syntax highlighter's span inside.+ ...Object.fromEntries(+ Array.from({ length: RAINBOW_COLORS }, (_, i) => [+ `.cm-sem-rainbow-${i + 1}, .cm-sem-rainbow-${i + 1} *`,+ {+ color: `var(--syn-rainbow-${i + 1})`,+ fontWeight: `var(--syn-rainbow-${i + 1}-bold, inherit)`,+ fontStyle: `var(--syn-rainbow-${i + 1}-italic, inherit)`,+ },+ ]),+ ),...markdown,});diff --git a/src/features/settings/pages/editor/colorScheme.tsx b/src/features/settings/pages/editor/colorScheme.tsxindex 8eecc45dd..05bc9fe91 100644--- a/src/features/settings/pages/editor/colorScheme.tsx+++ b/src/features/settings/pages/editor/colorScheme.tsx@@ -354,9 +354,27 @@ export const COLOR_SCHEME_PAGE = editorPage({"background","bold","italic",+ "rainbow",...SCHEMES.map((s) => s.name),],sections: [{ items: [{ t: "custom", label: "Scheme", keywords: ATTRIBUTES.map((a) => a.name), component: ColorSchemePage }] },+ {+ title: "Language Defaults",+ items: [+ {+ t: "check",+ key: "editor.semanticHighlighting",+ label: "Semantic highlighting",+ hint: "Local variables and parameters get a colour derived from their name (needs a language server).",+ },+ {+ t: "check",+ key: "editor.rainbowBrackets",+ label: "Rainbow brackets",+ hint: "Color (), [] and {} by nesting depth; unmatched brackets use the error color.",+ },+ ],+ },],});diff --git a/src/platform/colorScheme.ts b/src/platform/colorScheme.tsindex 5204fd523..a0f829489 100644--- a/src/platform/colorScheme.ts+++ b/src/platform/colorScheme.ts@@ -94,6 +94,8 @@ export const ATTRIBUTES: readonly AttributeDef[] = [syn("operator", "Braces and Operators", [LD], "punct"),syn("markupTag", "Markup › Tag", [LD], "tag"),syn("markupAttribute", "Markup › Attribute", [LD], "attribute"),+ ...[1, 2, 3, 4, 5].map((n) => syn(`semantic${n}`, `Semantic highlighting › Color ${n}`, [LD], `rainbow-${n}`)),+ ...[1, 2, 3].map((n) => syn(`bracket${n}`, `Rainbow brackets › Level ${n}`, [LD], `bracket-${n}`)),syn("pySelf", "Self parameter", ["Python"], "self"),syn("pyKeywordArg", "Keyword argument", ["Python"], "keyword-arg"),diff --git a/src/platform/editorSettings.ts b/src/platform/editorSettings.tsindex 04dd6bf51..a51d2fad3 100644--- a/src/platform/editorSettings.ts+++ b/src/platform/editorSettings.ts@@ -52,6 +52,10 @@ export function lineCommentStyleFor(prefs: EditorExtras, language: string | undeexport const EDITOR_EXTRA_DEFAULTS = {colorOverrides: {} as Record<string, Record<string, TextAttributesOverride>>,+ /** Color Scheme › Language Defaults › Semantic highlighting (rainbow locals / parameters). */+ semanticHighlighting: false,+ /** Color Scheme › Language Defaults › Rainbow brackets. */+ rainbowBrackets: false,ligatures: false,fallbackFont: "",/** Typography Settings › Main / Bold font weight (CSS weights, IDEA's Regular / Bold). */diff --git a/src/styles/tokens.css b/src/styles/tokens.cssindex 6bc00f49d..4d0307b67 100644--- a/src/styles/tokens.css+++ b/src/styles/tokens.css@@ -115,6 +115,14 @@ html {--syn-markup-code: #6aab73;--syn-invalid: #f75464;--syn-inline-value: #868a91;+ --syn-rainbow-1: #6fafbd;+ --syn-rainbow-2: #d79b6e;+ --syn-rainbow-3: #9fbf6b;+ --syn-rainbow-4: #c98bc6;+ --syn-rainbow-5: #8e9cf0;+ --syn-bracket-1: #e8c25b;+ --syn-bracket-2: #d78bd6;+ --syn-bracket-3: #4ea7f0;/* editor (scheme colours) */--fg-editor: #bcbec4;@@ -449,6 +457,14 @@ html {--syn-markup-code: #067d17;--syn-invalid: #f50000;--syn-inline-value: #8c8c8c;+ --syn-rainbow-1: #9b3b6a;+ --syn-rainbow-2: #114d77;+ --syn-rainbow-3: #9c6a2c;+ --syn-rainbow-4: #005910;+ --syn-rainbow-5: #bc5150;+ --syn-bracket-1: #0431fa;+ --syn-bracket-2: #319331;+ --syn-bracket-3: #7b3814;/* editor */--fg-editor: #080808;@@ -670,6 +686,14 @@ html {--syn-markup-code: #8ccc94;--syn-invalid: #ff8a95;--syn-inline-value: #a5a8ae;+ --syn-rainbow-1: #8fd0de;+ --syn-rainbow-2: #f0b88a;+ --syn-rainbow-3: #bedc8a;+ --syn-rainbow-4: #e8a8e4;+ --syn-rainbow-5: #b0bcff;+ --syn-bracket-1: #ffd700;+ --syn-bracket-2: #ee90ee;+ --syn-bracket-3: #87cefa;--fg-editor: #e3e4e8;--caret: #ffffff;diff --git a/templates/theme-plugin/themes/harbor-night.scheme.json b/templates/theme-plugin/themes/harbor-night.scheme.jsonindex 2a67c00c5..bfc824707 100644--- a/templates/theme-plugin/themes/harbor-night.scheme.json+++ b/templates/theme-plugin/themes/harbor-night.scheme.json@@ -35,6 +35,14 @@"--syn-markup-code": "#9ccc7a","--syn-invalid": "#ff6b7a","--syn-inline-value": "#6b7a8f",+ "--syn-rainbow-1": "#7fd1c4",+ "--syn-rainbow-2": "#e0a46e",+ "--syn-rainbow-3": "#b9a3f0",+ "--syn-rainbow-4": "#9ccc7a",+ "--syn-rainbow-5": "#e58fa3",+ "--syn-bracket-1": "#f2d07a",+ "--syn-bracket-2": "#d7a0e0",+ "--syn-bracket-3": "#6fc3df",// Editor"--fg-editor": "#d9dfe8",