From d20f765325c916e8588e49b104503d99ca4e2f93 Mon Sep 17 00:00:00 2001 From: "claude@clouddev1" Date: Fri, 29 May 2026 22:07:18 +0000 Subject: [PATCH] feat: give column data types a dedicated syntax-highlight colour MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both Node::Ident and Word carried a highlight_override field, and both were dead — the walker driver discarded the Ident's and walk_word hardcoded Keyword. So column types (int, serial, …) rendered identically to table/column names. Wire both overrides through, and add a dedicated HighlightClass::Type with its own theme colour (tok_type), distinct from keyword-purple and identifier-teal. The three type Ident slots opt in, so canonical types and the advanced-mode single-word SQL aliases (float, varchar, …) render as types; the two-word `double precision` alias opts in via a new Word::type_keyword constructor. ADR-0022 Amendment 4. --- docs/adr/0022-ambient-typing-assistance.md | 55 +++++++++++++++++ docs/adr/README.md | 2 +- docs/requirements.md | 4 ++ src/dsl/grammar/ddl.rs | 4 +- src/dsl/grammar/mod.rs | 21 +++++++ src/dsl/grammar/shared.rs | 6 +- src/dsl/grammar/sql_create_table.rs | 10 ++-- src/dsl/walker/driver.rs | 14 ++++- src/dsl/walker/highlight.rs | 70 ++++++++++++++++++++++ src/theme.rs | 22 +++++++ 10 files changed, 195 insertions(+), 13 deletions(-) diff --git a/docs/adr/0022-ambient-typing-assistance.md b/docs/adr/0022-ambient-typing-assistance.md index aa15796..9e066f0 100644 --- a/docs/adr/0022-ambient-typing-assistance.md +++ b/docs/adr/0022-ambient-typing-assistance.md @@ -587,6 +587,61 @@ guard above, and three re-baselined `typing_surface` snapshots (`form_a_in_progress_one_value`, `form_b_too_few_values`, `form_c_wrong_count`). +## Amendment 4 — Column types get a dedicated highlight class (2026-05-29) + +§3 introduced **seven** token-class colour fields and the matching +`HighlightClass` enum. Column data-type keywords (`int`, `serial`, +`text`, …) had no class of their own: the walker driver hardcoded +`HighlightClass::Identifier` for every matched `Node::Ident`, so a +type rendered identical to a table/column name (clause keywords were +already distinct, in `tok_keyword`). A user-reported bug (issue #8) +noted that in `create table Orders (count int, id serial PRIMARY KEY)` +the identifiers and the type keywords were indistinguishably teal. + +Both terminal kinds already carried a `highlight_override: +Option` field — `Node::Ident` and the `Word` struct +alike — but **both were dead**: the driver destructured the Ident's to +`_`, and `walk_word` hardcoded `Keyword`, neither ever consulting the +field. This amendment wires both through. + +**Change:** + +1. **New class.** `HighlightClass::Type` (the eighth variant) and a + matching eighth `Theme` field `tok_type`, populated in both + `dark()` and `light()` with a tone deliberately distinct from both + `tok_keyword` and `tok_identifier` (a pink / deep-magenta in the + red-purple range — the only free slot in the existing palette). + `highlight_class_color` maps the new variant. +2. **Overrides are now live.** `walk_ident` emits + `override.unwrap_or(Identifier)` and `walk_word` emits + `override.unwrap_or(Keyword)` for the matched byte range. Every + slot that leaves the field `None` is unchanged. +3. **Type slots opt in.** The three `IdentSource::Types` slots — + `shared::TYPE_SLOT` (`add column` / `change column`), the inline + create-table column-type Ident (`ddl.rs`), and `sql_create_table:: + SQL_TYPE_NAME` (advanced) — set `highlight_override: Some(Type)`. + In advanced mode, every single-word SQL type-name *alias* + (`float`, `varchar`, `integer`, … — ADR-0035 §3) flows through + `SQL_TYPE_NAME` and so is type-coloured for free. +4. **`double precision` too.** The lone two-word alias (ADR-0035 §3) + is matched as keyword tokens, not an `IdentSource::Types` Ident, so + it cannot ride rule 3. Its `double` / `precision` grammar nodes use + the new `Word::type_keyword` constructor (`highlight_override: + Some(Type)`) so the spelling renders type-coloured like its + single-word synonyms `float` / `real`. + +**Pedagogy:** a dedicated colour (over the lighter option of reusing +`tok_keyword`) lets a learner tell *"this is a type"* from a clause +keyword and from a name they invented — three distinct roles, three +distinct colours. + +**Coverage:** `dsl_type_keyword_classified_as_type`, +`advanced_type_keywords_classified_as_type` (the ticket's exact +example), `advanced_double_precision_classified_as_type`, +`type_colour_is_distinct_from_keyword_and_identifier`, and the +extended theme mapping/contrast tests. Text snapshots are colour-blind +(`render_to_string` strips style), so none churned. + ## Out of scope Deliberately deferred to keep this ADR shippable as a single diff --git a/docs/adr/README.md b/docs/adr/README.md index a23a129..79a153a 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -27,7 +27,7 @@ This directory contains the project's ADRs, recorded per - [ADR-0019 — Friendly error layer (H1) and i18n message catalog](0019-friendly-error-layer-and-i18n.md) - [ADR-0020 — Tokenization layer for the DSL parser](0020-tokenization-layer-for-the-dsl-parser.md) - [ADR-0021 — Parser-as-source-of-truth for H1a (per-command usage in parse errors)](0021-parser-as-source-of-truth-for-h1a.md) -- [ADR-0022 — Ambient typing assistance: colour, hint panel, completion (I3 + I4)](0022-ambient-typing-assistance.md) — **Amendment 1 supersedes §12's simple-mode-only carve-out**: the unified mode-aware walker (ADR-0030/0031/0032) now speaks SQL, so advanced-mode ambient assistance is re-enabled. `ambient_hint_in_mode` + `hint_resolution_at_input_in_mode` + `expected_for_hint_snapshot` thread `Mode`; `render_hint_panel` calls ambient for all modes (no more advanced-mode `None`); the one-shot `:` sigil is stripped before the ambient walk. Fixes a live bug where advanced-mode SQL hinting/completion-preview were dead despite Phase 2 marking them green (validated at the engine layer, not the UI). Simple-mode gating, highlighting, and the §13 performance posture are unchanged; covered by an app-level render test plus ambient-layer regression locks; **Amendment 2 reverses the handoff-14 keywords-first candidate ordering** — schema identifiers (table/column/relationship names) now sort *before* keywords so a name the user would have to look up stays visible in the single-row, window-scrolled candidate line (keywords are learned over time; the `tok_identifier`/`tok_keyword` colour split marks the boundary); shipped with a `walk_repeated` fix that surfaces a list item's trailing optionals at a clean boundary (`order by Name ` → `asc`/`desc`, `select Name ` → `as`, `create table … Code(text) ` → `not`/`unique`/`default`/`check`; the `,` separator deliberately not surfaced); records a deferred two-line hint box for growing lists; **Amendment 3 makes the ambient-hint fallback rung schema-aware** — Amendment 1's bottom-rung `parse_command_in_mode` was schemaless while every earlier rung was not, so between-values insert hints pointed at `)` (type-blind close) instead of `,` and wrong-arity closed tuples read "submit with Enter" for an input the schema-aware parse rejects (issue #2); now uses `parse_command_with_schema_in_mode`, no extra walk, with the friendly arity diagnostic still winning at its higher rung +- [ADR-0022 — Ambient typing assistance: colour, hint panel, completion (I3 + I4)](0022-ambient-typing-assistance.md) — **Amendment 1 supersedes §12's simple-mode-only carve-out**: the unified mode-aware walker (ADR-0030/0031/0032) now speaks SQL, so advanced-mode ambient assistance is re-enabled. `ambient_hint_in_mode` + `hint_resolution_at_input_in_mode` + `expected_for_hint_snapshot` thread `Mode`; `render_hint_panel` calls ambient for all modes (no more advanced-mode `None`); the one-shot `:` sigil is stripped before the ambient walk. Fixes a live bug where advanced-mode SQL hinting/completion-preview were dead despite Phase 2 marking them green (validated at the engine layer, not the UI). Simple-mode gating, highlighting, and the §13 performance posture are unchanged; covered by an app-level render test plus ambient-layer regression locks; **Amendment 2 reverses the handoff-14 keywords-first candidate ordering** — schema identifiers (table/column/relationship names) now sort *before* keywords so a name the user would have to look up stays visible in the single-row, window-scrolled candidate line (keywords are learned over time; the `tok_identifier`/`tok_keyword` colour split marks the boundary); shipped with a `walk_repeated` fix that surfaces a list item's trailing optionals at a clean boundary (`order by Name ` → `asc`/`desc`, `select Name ` → `as`, `create table … Code(text) ` → `not`/`unique`/`default`/`check`; the `,` separator deliberately not surfaced); records a deferred two-line hint box for growing lists; **Amendment 3 makes the ambient-hint fallback rung schema-aware** — Amendment 1's bottom-rung `parse_command_in_mode` was schemaless while every earlier rung was not, so between-values insert hints pointed at `)` (type-blind close) instead of `,` and wrong-arity closed tuples read "submit with Enter" for an input the schema-aware parse rejects (issue #2); now uses `parse_command_with_schema_in_mode`, no extra walk, with the friendly arity diagnostic still winning at its higher rung; **Amendment 4 gives column types a dedicated highlight class** — both `Node::Ident.highlight_override` *and* the `Word.highlight_override` field were dead (driver destructured the former to `_`, `walk_word` hardcoded `Keyword`); now both wired through, with a new `HighlightClass::Type` + eighth `Theme` field `tok_type` (a pink/deep-magenta distinct from both keyword purple and identifier teal) so types no longer render identically to identifiers (issue #8); the three `IdentSource::Types` slots opt in via `Some(Type)` (advanced-mode single-word SQL aliases — `float`, `varchar`, … per ADR-0035 §3 — ride along for free), and the two-word `double precision` alias opts in via the new `Word::type_keyword` constructor so it matches its synonyms - [ADR-0023 — Unified declarative grammar tree](0023-unified-grammar-tree.md) — direction (superseded for execution detail by ADR-0024) - [ADR-0024 — Unified grammar tree: execution plan](0024-unified-grammar-tree-execution-plan.md) — **Accepted**, the executable spec — implemented (Phases A–F; Phase F shipped "minimal", `parser.rs` retained as the router — see the ADR's Phase F implementation note) - [ADR-0025 — Indexes](0025-indexes.md) — **Accepted** (**Amendment 1, 2026-05-25**: UNIQUE indexes admitted on the **advanced-mode** surface via `CREATE UNIQUE INDEX` — ADR-0035 §4d; the `IndexSchema.unique` flag round-trips through `project.yaml` with no new metadata table since the engine reports uniqueness natively; simple-mode `add unique index` stays deferred), `add index` / `drop index`, persistence, rebuild-table preservation, and items-list display (`C3` index portion + `S2`) diff --git a/docs/requirements.md b/docs/requirements.md index 4dab829..57661ee 100644 --- a/docs/requirements.md +++ b/docs/requirements.md @@ -106,6 +106,10 @@ handoff-14 cleanup; 449 after B2/C2.) - [ ] **I3** Tab completion for app commands, DSL keywords, table names, column names, and SQL keywords. - [ ] **I4** Syntax highlighting for both the DSL and SQL. + *(Refinement 2026-05-29, issue #8: column data types now carry a + dedicated `HighlightClass::Type` / `tok_type` colour, distinct from + identifiers and clause keywords — ADR-0022 Amendment 4. The broad + highlighting goal stays open.)* - [ ] **I5** In-flight query/command cancellation (Ctrl-C in the output area or input field). diff --git a/src/dsl/grammar/ddl.rs b/src/dsl/grammar/ddl.rs index 215fbf6..7c16ca8 100644 --- a/src/dsl/grammar/ddl.rs +++ b/src/dsl/grammar/ddl.rs @@ -18,7 +18,7 @@ use crate::dsl::command::{ }; use crate::dsl::value::Value; use crate::dsl::grammar::{ - CommandNode, HintMode, IdentSource, Node, ValidationError, Word, + CommandNode, HighlightClass, HintMode, IdentSource, Node, ValidationError, Word, shared::{REFERENTIAL_CLAUSES, TYPE_SLOT, TYPE_VALIDATOR}, }; @@ -1079,7 +1079,7 @@ const COL_SPEC_NODES: &[Node] = &[ source: IdentSource::Types, role: "col_type", validator: Some(TYPE_VALIDATOR), - highlight_override: None, + highlight_override: Some(HighlightClass::Type), writes_table: false, writes_column: false, writes_user_listed_column: false, diff --git a/src/dsl/grammar/mod.rs b/src/dsl/grammar/mod.rs index 89533b0..a886076 100644 --- a/src/dsl/grammar/mod.rs +++ b/src/dsl/grammar/mod.rs @@ -47,6 +47,12 @@ use crate::dsl::walker::outcome::MatchedPath; pub enum HighlightClass { Keyword, Identifier, + /// Column data-type keyword (`int`, `serial`, `text`, …). + /// Distinct from `Keyword` and `Identifier` so learners can + /// tell "this is a type" from a clause keyword or a name they + /// invented (ADR-0022 Amendment 4). Assigned via a type slot's + /// `highlight_override`, not by byte shape. + Type, Number, String, Punct, @@ -191,6 +197,21 @@ impl Word { } } + /// A keyword that highlights as a column **type** rather than a + /// clause keyword (ADR-0022 Amendment 4). The one user today is + /// the two-word `double precision` SQL alias (ADR-0035 §3): it + /// is matched as keyword tokens, not an `IdentSource::Types` + /// `Ident`, so without this it would render keyword-coloured + /// while its single-word synonyms (`float`, `real`) render as + /// types. + pub const fn type_keyword(primary: &'static str) -> Self { + Self { + primary, + aliases: &[], + highlight_override: Some(HighlightClass::Type), + } + } + /// Case-insensitive match against the primary or any alias. pub fn matches(&self, candidate: &str) -> bool { if candidate.eq_ignore_ascii_case(self.primary) { diff --git a/src/dsl/grammar/shared.rs b/src/dsl/grammar/shared.rs index 7a6e320..c62c2dc 100644 --- a/src/dsl/grammar/shared.rs +++ b/src/dsl/grammar/shared.rs @@ -7,8 +7,8 @@ use crate::completion::TableColumn; use crate::dsl::grammar::{ - HintMode, IdentSource, IdentValidator, Node, NumberValidator, - ValidationError, Word, + HighlightClass, HintMode, IdentSource, IdentValidator, Node, + NumberValidator, ValidationError, Word, }; use crate::dsl::types::Type; use crate::dsl::walker::context::WalkContext; @@ -50,7 +50,7 @@ pub const TYPE_SLOT: Node = Node::Ident { source: IdentSource::Types, role: "type", validator: Some(TYPE_VALIDATOR), - highlight_override: None, + highlight_override: Some(HighlightClass::Type), writes_table: false, writes_column: false, writes_user_listed_column: false, diff --git a/src/dsl/grammar/sql_create_table.rs b/src/dsl/grammar/sql_create_table.rs index c30e24c..0cfb9f7 100644 --- a/src/dsl/grammar/sql_create_table.rs +++ b/src/dsl/grammar/sql_create_table.rs @@ -24,7 +24,9 @@ //! `sql_insert::SQL_INSERT_SHAPE`, which starts at `INTO`). use crate::dsl::grammar::sql_select::reject_internal_table; -use crate::dsl::grammar::{IdentSource, Node, ValidationError, Word, shared, sql_expr}; +use crate::dsl::grammar::{ + HighlightClass, IdentSource, Node, ValidationError, Word, shared, sql_expr, +}; use crate::dsl::types::Type; static COMMA: Node = Node::Punct(','); @@ -60,7 +62,7 @@ const SQL_TYPE_NAME: Node = Node::Ident { source: IdentSource::Types, role: "col_type", validator: Some(validate_sql_type_name), - highlight_override: None, + highlight_override: Some(HighlightClass::Type), writes_table: false, writes_column: false, writes_user_listed_column: false, @@ -86,8 +88,8 @@ const LENGTH_OPT: Node = Node::Optional(&Node::Seq(LENGTH_NODES)); // on its own (ADR-0035 §6.3). The builder maps the pair to // `Type::Real`. static DOUBLE_PRECISION_NODES: &[Node] = &[ - Node::Word(Word::keyword("double")), - Node::Word(Word::keyword("precision")), + Node::Word(Word::type_keyword("double")), + Node::Word(Word::type_keyword("precision")), ]; static TYPE_WITH_LENGTH_NODES: &[Node] = &[SQL_TYPE_NAME, LENGTH_OPT]; static SQL_TYPE_CHOICES: &[Node] = &[ diff --git a/src/dsl/walker/driver.rs b/src/dsl/walker/driver.rs index a8baac5..e14f04f 100644 --- a/src/dsl/walker/driver.rs +++ b/src/dsl/walker/driver.rs @@ -180,7 +180,7 @@ fn walk_node_inner( source: src, role, validator, - highlight_override: _, + highlight_override, writes_table, writes_column, writes_user_listed_column, @@ -193,6 +193,7 @@ fn walk_node_inner( *src, role, *validator, + *highlight_override, *writes_table, *writes_column, *writes_user_listed_column, @@ -336,7 +337,10 @@ fn walk_word( per_byte.push(ByteClass { start, end, - class: HighlightClass::Keyword, + // A keyword may opt into a non-default colour via + // `Word::type_keyword` (e.g. `double precision`, ADR-0022 + // Amendment 4). Plain keywords leave it `None`. + class: word.highlight_override.unwrap_or(HighlightClass::Keyword), }); NodeWalkResult::Matched { end, skipped: Vec::new() } } else { @@ -397,6 +401,7 @@ fn walk_ident( src: crate::dsl::grammar::IdentSource, role: &'static str, validator: Option, + highlight_override: Option, writes_table: bool, writes_column: bool, writes_user_listed_column: bool, @@ -554,7 +559,10 @@ fn walk_ident( per_byte.push(ByteClass { start, end, - class: HighlightClass::Identifier, + // A type slot (and any future slot that wants a non-default + // colour) overrides the otherwise-uniform Identifier class + // (issue #8 / ADR-0022 Amendment 4). + class: highlight_override.unwrap_or(HighlightClass::Identifier), }); NodeWalkResult::Matched { end, skipped: Vec::new() } } diff --git a/src/dsl/walker/highlight.rs b/src/dsl/walker/highlight.rs index 9616db0..e5a4b9a 100644 --- a/src/dsl/walker/highlight.rs +++ b/src/dsl/walker/highlight.rs @@ -297,6 +297,76 @@ mod tests { assert_eq!(runs[1].2, HighlightClass::Keyword); } + #[test] + fn dsl_type_keyword_classified_as_type() { + // Issue #8 / ADR-0022 Amendment 4: the column type in a DSL + // `create table` (`serial`) is a Type, distinct from the + // identifiers `T` / `id` which stay Identifier. + let runs = run("create table T with pk id(serial)"); + // `serial` occupies bytes 26..32 in the input. + let serial = runs + .iter() + .find(|(s, e, _)| &"create table T with pk id(serial)"[*s..*e] == "serial") + .expect("serial run present"); + assert_eq!(serial.2, HighlightClass::Type); + // The invented identifiers are NOT typed. + for name in ["T", "id"] { + let r = runs + .iter() + .find(|(s, e, _)| &"create table T with pk id(serial)"[*s..*e] == name) + .unwrap_or_else(|| panic!("{name} run present")); + assert_eq!(r.2, HighlightClass::Identifier, "{name} stays Identifier"); + } + } + + #[test] + fn advanced_type_keywords_classified_as_type() { + // Issue #8: the exact example from the ticket. In advanced + // mode the SQL type keywords `int` / `serial` are Type; + // `Orders` / `count` / `id` stay Identifier. + let input = "create table Orders (count int, id serial)"; + let runs: Vec<(usize, usize, HighlightClass)> = + highlight_runs_in_mode(input, crate::mode::Mode::Advanced) + .into_iter() + .map(|c| (c.start, c.end, c.class)) + .collect(); + let class_of = |needle: &str| { + runs.iter() + .find(|(s, e, _)| &input[*s..*e] == needle) + .unwrap_or_else(|| panic!("{needle} run present")) + .2 + }; + assert_eq!(class_of("int"), HighlightClass::Type); + assert_eq!(class_of("serial"), HighlightClass::Type); + assert_eq!(class_of("Orders"), HighlightClass::Identifier); + assert_eq!(class_of("count"), HighlightClass::Identifier); + assert_eq!(class_of("id"), HighlightClass::Identifier); + } + + #[test] + fn advanced_double_precision_classified_as_type() { + // Issue #8 follow-up: the two-word `double precision` SQL + // alias (ADR-0035 §3) is matched as keyword tokens, but + // `Word::type_keyword` colours it as a type so it matches + // its single-word synonyms `float` / `real`. Both words + // carry the Type class. + let input = "create table T (x double precision)"; + let runs: Vec<(usize, usize, HighlightClass)> = + highlight_runs_in_mode(input, crate::mode::Mode::Advanced) + .into_iter() + .map(|c| (c.start, c.end, c.class)) + .collect(); + let class_of = |needle: &str| { + runs.iter() + .find(|(s, e, _)| &input[*s..*e] == needle) + .unwrap_or_else(|| panic!("{needle} run present")) + .2 + }; + assert_eq!(class_of("double"), HighlightClass::Type); + assert_eq!(class_of("precision"), HighlightClass::Type); + assert_eq!(class_of("x"), HighlightClass::Identifier); + } + #[test] fn full_command_walks_with_each_class() { // `update T set Name='hi' --all-rows` — walker covers it diff --git a/src/theme.rs b/src/theme.rs index 1c907ff..15a161a 100644 --- a/src/theme.rs +++ b/src/theme.rs @@ -51,6 +51,11 @@ pub struct Theme { // ---- Per-token-class colours (ADR-0022 §3) ------------------- pub tok_keyword: Color, pub tok_identifier: Color, + /// Column data-type keyword colour (ADR-0022 Amendment 4) — + /// a dedicated tone distinct from both `tok_keyword` and + /// `tok_identifier` so a learner can tell a type from a + /// clause keyword or an invented name at a glance. + pub tok_type: Color, pub tok_number: Color, pub tok_string: Color, pub tok_punct: Color, @@ -84,6 +89,7 @@ impl Theme { // distinct from the mode-banner blue. tok_keyword: Color::Rgb(0xC7, 0x92, 0xEA), // muted purple tok_identifier: Color::Rgb(0x56, 0xB6, 0xC2), // cyan-teal — identifiers are the user's content, deserve a vivid distinct colour + tok_type: Color::Rgb(0xF0, 0x8F, 0xC0), // pink — types sit in the red-purple range, clearly apart from the lavender keyword and teal identifier tok_number: Color::Rgb(0xF7, 0x8C, 0x6C), // warm orange tok_string: Color::Rgb(0xC3, 0xE8, 0x8D), // soft green tok_punct: Color::Rgb(0x8B, 0x90, 0x9A), // == muted @@ -113,6 +119,7 @@ impl Theme { // literals + flags; cool accent for keyword. tok_keyword: Color::Rgb(0x6F, 0x42, 0xC1), // royal purple tok_identifier: Color::Rgb(0x0F, 0x6B, 0x76), // deep teal — same role as dark variant: identifiers stand out + tok_type: Color::Rgb(0xA8, 0x2D, 0x73), // deep magenta — red-purple, distinct from royal-purple keyword + teal identifier tok_number: Color::Rgb(0xBC, 0x4F, 0x1F), // burnt orange tok_string: Color::Rgb(0x22, 0x86, 0x3A), // forest green tok_punct: Color::Rgb(0x60, 0x66, 0x73), // == muted @@ -132,6 +139,7 @@ impl Theme { match class { HighlightClass::Keyword => self.tok_keyword, HighlightClass::Identifier => self.tok_identifier, + HighlightClass::Type => self.tok_type, HighlightClass::Number => self.tok_number, HighlightClass::String => self.tok_string, HighlightClass::Punct => self.tok_punct, @@ -156,6 +164,7 @@ mod tests { let t = Theme::dark(); for (name, c) in [ ("tok_keyword", t.tok_keyword), + ("tok_type", t.tok_type), ("tok_number", t.tok_number), ("tok_string", t.tok_string), ("tok_flag", t.tok_flag), @@ -174,6 +183,7 @@ mod tests { let t = Theme::light(); for (name, c) in [ ("tok_keyword", t.tok_keyword), + ("tok_type", t.tok_type), ("tok_number", t.tok_number), ("tok_string", t.tok_string), ("tok_flag", t.tok_flag), @@ -192,10 +202,22 @@ mod tests { let t = Theme::dark(); assert_eq!(t.highlight_class_color(HighlightClass::Keyword), t.tok_keyword); assert_eq!(t.highlight_class_color(HighlightClass::Identifier), t.tok_identifier); + assert_eq!(t.highlight_class_color(HighlightClass::Type), t.tok_type); assert_eq!(t.highlight_class_color(HighlightClass::Number), t.tok_number); assert_eq!(t.highlight_class_color(HighlightClass::String), t.tok_string); assert_eq!(t.highlight_class_color(HighlightClass::Punct), t.tok_punct); assert_eq!(t.highlight_class_color(HighlightClass::Flag), t.tok_flag); assert_eq!(t.highlight_class_color(HighlightClass::Error), t.tok_error); } + + #[test] + fn type_colour_is_distinct_from_keyword_and_identifier() { + // ADR-0022 Amendment 4 / issue #8: the whole point of a + // dedicated type class is that types do NOT share a colour + // with clause keywords or invented identifiers. + for t in [Theme::dark(), Theme::light()] { + assert_ne!(t.tok_type, t.tok_keyword); + assert_ne!(t.tok_type, t.tok_identifier); + } + } }